robotcode-analyze 2.4.0__tar.gz → 2.5.1__tar.gz

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/.gitignore

@@ -334,4 +334,8 @@ bundled/libs
 results/
 
 # kilocode
-.kilocode/
+.kilocode/
+
+# .agents
+.agents/
+skills-lock.json

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-analyze
-Version: 2.4.0
+Version: 2.5.1
 Summary: RobotCode analyze plugin for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode

robotcode_analyze-2.5.1/src/robotcode/analyze/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.5.1"

robotcode_analyze-2.5.1/src/robotcode/analyze/cache/cli.py

@@ -0,0 +1,421 @@
+from pathlib import Path
+from typing import Optional, Tuple
+
+import click
+
+from robotcode.plugin import Application, OutputFormat, pass_application
+from robotcode.robot.config.loader import load_robot_config_from_path
+from robotcode.robot.config.utils import get_config_files
+from robotcode.robot.diagnostics.data_cache import (
+    _LOCK_FILE_NAME,
+    CACHE_DIR_NAME,
+    CacheSection,
+    SqliteDataCache,
+    build_cache_dir,
+    exclusive_cache_lock,
+    resolve_cache_base_path,
+)
+
+from ..config import AnalyzeConfig
+
+_SECTION_NAMES = {s.name.lower(): s for s in CacheSection}
+
+
+def _resolve_cache(
+    app: Application,
+    paths: Tuple[Path, ...],
+) -> Tuple[Path, Optional[SqliteDataCache]]:
+    config_files, root_folder, _ = get_config_files(
+        paths,
+        app.config.config_files,
+        root_folder=app.config.root,
+        no_vcs=app.config.no_vcs,
+        verbose_callback=app.verbose,
+    )
+
+    robot_config = load_robot_config_from_path(
+        *config_files, extra_tools={"robotcode-analyze": AnalyzeConfig}, verbose_callback=app.verbose
+    )
+
+    analyzer_config = robot_config.tool.get("robotcode-analyze", None) if robot_config.tool is not None else None
+
+    cache_base_path = root_folder or Path.cwd()
+    if analyzer_config is not None and isinstance(analyzer_config, AnalyzeConfig):
+        if analyzer_config.cache is not None and analyzer_config.cache.cache_dir is not None:
+            cache_base_path = Path(analyzer_config.cache.cache_dir)
+
+    cache_base_path = resolve_cache_base_path(cache_base_path)
+
+    cache_dir = build_cache_dir(cache_base_path)
+
+    if not cache_dir.exists() or not (cache_dir / "cache.db").exists():
+        return cache_dir, None
+
+    from ..__version__ import __version__
+
+    return cache_dir, SqliteDataCache(cache_dir, app_version=__version__)
+
+
+def _parse_sections(sections: Tuple[str, ...]) -> Optional[Tuple[CacheSection, ...]]:
+    if not sections:
+        return None
+
+    result = []
+    for s in sections:
+        s_lower = s.lower()
+        if s_lower not in _SECTION_NAMES:
+            raise click.BadParameter(
+                f"Unknown section '{s}'. Choose from: {', '.join(_SECTION_NAMES)}",
+                param_hint="'--section'",
+            )
+        result.append(_SECTION_NAMES[s_lower])
+    return tuple(result)
+
+
+def _format_bytes(n: int) -> str:
+    if n < 1024:
+        return f"{n} B"
+    if n < 1024 * 1024:
+        return f"{n / 1024:.1f} KB"
+    return f"{n / (1024 * 1024):.1f} MB"
+
+
+@click.group(
+    name="cache",
+    add_help_option=True,
+    invoke_without_command=False,
+)
+def cache_group() -> None:
+    """\
+    Manage the RobotCode analysis cache.
+
+    Provides subcommands to inspect, list, and clear cached data
+    (library docs, variables, resources, namespaces).
+    """
+
+
+@cache_group.command(name="path")
+@click.argument(
+    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
+)
+@pass_application
+def cache_path(app: Application, paths: Tuple[Path, ...]) -> None:
+    """\
+    Print the cache directory path.
+
+    Outputs the resolved cache directory for the current project
+    and Python/Robot Framework version combination.
+    """
+    cache_dir, db = _resolve_cache(app, paths)
+    try:
+        app.echo(str(cache_dir))
+    finally:
+        if db is not None:
+            db.close()
+
+
+@cache_group.command(name="info")
+@click.argument(
+    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
+)
+@pass_application
+def cache_info(app: Application, paths: Tuple[Path, ...]) -> None:
+    """\
+    Show cache statistics.
+
+    Displays the cache directory, database size, app version, and
+    per-section entry counts with timestamps.
+    """
+    cache_dir, db = _resolve_cache(app, paths)
+
+    if db is None:
+        app.echo(f"Cache directory: {cache_dir}")
+        app.echo("No cache database found.")
+        return
+
+    try:
+        db_path = db.db_path
+        db_size = db_path.stat().st_size if db_path.exists() else 0
+
+        section_data = []
+        total_entries = 0
+        total_bytes = 0
+        for section in CacheSection:
+            stats = db.get_section_stats(section)
+            total_entries += stats.entry_count
+            total_bytes += stats.total_blob_bytes
+            section_data.append(
+                {
+                    "section": section.name.lower(),
+                    "entries": stats.entry_count,
+                    "size": stats.total_blob_bytes,
+                    "size_formatted": _format_bytes(stats.total_blob_bytes) if stats.entry_count else "—",
+                    "created": stats.oldest_created or None,
+                    "modified": stats.newest_modified or None,
+                }
+            )
+
+        if app.config.output_format is None or app.config.output_format == OutputFormat.TEXT:
+            if app.colored and app.has_rich:
+                lines = [
+                    f"- **Directory:** {cache_dir}",
+                    f"- **Database:** {db_path.name} ({_format_bytes(db_size)})",
+                    f"- **Version:** {db.app_version or '(unknown)'}",
+                    "",
+                    "| Section | Entries | Size | Created | Modified |",
+                    "|---|---:|---:|---|---|",
+                ]
+                for s in section_data:
+                    lines.append(
+                        f"| {s['section']} | {s['entries']} | {s['size_formatted']}"
+                        f" | {s['created'] or '—'} | {s['modified'] or '—'} |"
+                    )
+                lines.append(f"| **Total** | **{total_entries}** | **{_format_bytes(total_bytes)}** | | |")
+                app.echo_as_markdown("\n".join(lines))
+            else:
+                app.echo(f"  Directory:  {cache_dir}")
+                app.echo(f"  Database:   {db_path.name}  ({_format_bytes(db_size)})")
+                app.echo(f"  Version:    {db.app_version or '(unknown)'}")
+                app.echo("")
+                header = f"  {'Section':<12} {'Entries':>7}  {'Size':>10}  {'Created':19}  {'Modified':19}"
+                app.echo(header)
+                app.echo(f"  {'─' * (len(header) - 2)}")
+                for s in section_data:
+                    app.echo(
+                        f"  {s['section']:<12} {s['entries']:>7}  {s['size_formatted']:>10}"
+                        f"  {(s['created'] or '—'):19}  {(s['modified'] or '—'):19}"
+                    )
+                app.echo(f"  {'─' * (len(header) - 2)}")
+                app.echo(f"  {'Total':<12} {total_entries:>7}  {_format_bytes(total_bytes):>10}")
+        else:
+            app.print_data(
+                {
+                    "directory": str(cache_dir),
+                    "database": db_path.name,
+                    "database_size": db_size,
+                    "version": db.app_version or "",
+                    "sections": [
+                        {k: v for k, v in s.items() if k != "size_formatted" and v is not None} for s in section_data
+                    ],
+                    "total_entries": total_entries,
+                    "total_size": total_bytes,
+                }
+            )
+    finally:
+        db.close()
+
+
+@cache_group.command(name="list")
+@click.option(
+    "-s",
+    "--section",
+    "sections",
+    multiple=True,
+    metavar="SECTION",
+    help="Filter by section (library, variables, resource, namespace). Can be specified multiple times.",
+)
+@click.option(
+    "-p",
+    "--pattern",
+    "patterns",
+    multiple=True,
+    metavar="PATTERN",
+    help="Filter entries by glob pattern (e.g. 'robot.*', '*BuiltIn*'). Can be specified multiple times.",
+)
+@click.argument(
+    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
+)
+@pass_application
+def cache_list(app: Application, sections: Tuple[str, ...], patterns: Tuple[str, ...], paths: Tuple[Path, ...]) -> None:
+    """\
+    List cached entries.
+
+    Shows all entries in the cache with their timestamps and sizes.
+    Use --section to filter by specific cache sections.
+    Use --pattern to filter entries by glob pattern.
+    """
+    from fnmatch import fnmatch
+
+    _, db = _resolve_cache(app, paths)
+
+    if db is None:
+        app.echo("No cache database found.")
+        return
+
+    try:
+        selected = _parse_sections(sections)
+        target_sections = selected if selected else tuple(CacheSection)
+
+        def _matches(name: str) -> bool:
+            if not patterns:
+                return True
+            return any(fnmatch(name, p) for p in patterns)
+
+        if app.config.output_format is None or app.config.output_format == OutputFormat.TEXT:
+            if app.colored and app.has_rich:
+                lines: list[str] = []
+                for section in target_sections:
+                    entries = [e for e in db.list_entries(section) if _matches(e.entry_name)]
+                    if not entries:
+                        continue
+                    lines.append(f"### {section.name.lower()} ({len(entries)} entries)")
+                    lines.append("")
+                    lines.append("| Name | Size | Created | Modified |")
+                    lines.append("|---|---:|---|---|")
+                    for entry in entries:
+                        size = _format_bytes(entry.meta_bytes + entry.data_bytes)
+                        created = entry.created_at or "—"
+                        modified = entry.modified_at or "—"
+                        lines.append(f"| {entry.entry_name} | {size} | {created} | {modified} |")
+                    lines.append("")
+                if lines:
+                    app.echo_as_markdown("\n".join(lines))
+                else:
+                    app.echo("No entries found.")
+            else:
+                found = False
+                for section in target_sections:
+                    entries = [e for e in db.list_entries(section) if _matches(e.entry_name)]
+                    if not entries:
+                        continue
+                    found = True
+                    app.echo(f"[{section.name.lower()}] ({len(entries)} entries)")
+                    for entry in entries:
+                        size = _format_bytes(entry.meta_bytes + entry.data_bytes)
+                        created = entry.created_at or "—"
+                        modified = entry.modified_at or "—"
+                        app.echo(f"  {entry.entry_name}  size={size}  created={created}  modified={modified}")
+                    app.echo("")
+                if not found:
+                    app.echo("No entries found.")
+        else:
+            result: dict[str, list[dict[str, object]]] = {}
+            for section in target_sections:
+                entries = [e for e in db.list_entries(section) if _matches(e.entry_name)]
+                if entries:
+                    result[section.name.lower()] = [
+                        {
+                            k: v
+                            for k, v in {
+                                "name": e.entry_name,
+                                "size": e.meta_bytes + e.data_bytes,
+                                "created": e.created_at,
+                                "modified": e.modified_at,
+                            }.items()
+                            if v is not None
+                        }
+                        for e in entries
+                    ]
+            app.print_data(result)
+    finally:
+        db.close()
+
+
+@cache_group.command(name="clear")
+@click.option(
+    "-s",
+    "--section",
+    "sections",
+    multiple=True,
+    metavar="SECTION",
+    help="Clear only specific sections (library, variables, resource, namespace). Can be specified multiple times.",
+)
+@click.argument(
+    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
+)
+@pass_application
+def cache_clear(app: Application, sections: Tuple[str, ...], paths: Tuple[Path, ...]) -> None:
+    """\
+    Clear the analysis cache.
+
+    Removes cached entries from the database. By default clears all sections.
+    Use --section to clear specific sections only.
+    """
+    _, db = _resolve_cache(app, paths)
+
+    if db is None:
+        app.echo("No cache database found.")
+        return
+
+    try:
+        selected = _parse_sections(sections)
+
+        if selected:
+            total = 0
+            for section in selected:
+                count = db.clear_section(section)
+                total += count
+                app.echo(f"Cleared {count} entries from {section.name.lower()}.")
+        else:
+            total = db.clear_all()
+
+        app.echo(f"Removed {total} entries total.")
+    finally:
+        db.close()
+
+
+def _resolve_cache_root(
+    app: Application,
+    paths: Tuple[Path, ...],
+) -> Path:
+    config_files, root_folder, _ = get_config_files(
+        paths,
+        app.config.config_files,
+        root_folder=app.config.root,
+        no_vcs=app.config.no_vcs,
+        verbose_callback=app.verbose,
+    )
+
+    robot_config = load_robot_config_from_path(
+        *config_files, extra_tools={"robotcode-analyze": AnalyzeConfig}, verbose_callback=app.verbose
+    )
+
+    analyzer_config = robot_config.tool.get("robotcode-analyze", None) if robot_config.tool is not None else None
+
+    cache_base_path = root_folder or Path.cwd()
+    if analyzer_config is not None and isinstance(analyzer_config, AnalyzeConfig):
+        if analyzer_config.cache is not None and analyzer_config.cache.cache_dir is not None:
+            cache_base_path = Path(analyzer_config.cache.cache_dir)
+
+    cache_base_path = resolve_cache_base_path(cache_base_path)
+
+    return cache_base_path / CACHE_DIR_NAME
+
+
+@cache_group.command(name="prune")
+@click.option("--force", is_flag=True, help="Force prune even if cache is in use by another process.")
+@click.argument(
+    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
+)
+@pass_application
+def cache_prune(app: Application, force: bool, paths: Tuple[Path, ...]) -> None:
+    """\
+    Remove the entire cache directory.
+
+    Deletes the .robotcode_cache directory and all its contents,
+    including caches for all Python and Robot Framework versions.
+    """
+    import shutil
+
+    cache_root = _resolve_cache_root(app, paths)
+
+    if not cache_root.exists():
+        app.echo(f"Cache directory does not exist: {cache_root}")
+        return
+
+    if not force:
+        locked_dirs = []
+        for lock_file in cache_root.rglob(_LOCK_FILE_NAME):
+            with exclusive_cache_lock(lock_file.parent) as acquired:
+                if not acquired:
+                    locked_dirs.append(lock_file.parent)
+
+        if locked_dirs:
+            app.echo("Cannot prune: cache is in use by another process.")
+            for d in locked_dirs:
+                app.echo(f"  Locked: {d}")
+            app.echo("Use --force to override.")
+            return
+
+    shutil.rmtree(cache_root)
+    app.echo(f"Removed {cache_root}")

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/src/robotcode/analyze/cli.py

@@ -3,6 +3,7 @@ import click
 from robotcode.plugin import Application, pass_application
 
 from .__version__ import __version__
+from .cache.cli import cache_group
 from .code.cli import code
 
 
@@ -23,4 +24,5 @@ def analyze(app: Application) -> None:
     """
 
 
+analyze.add_command(cache_group)
 analyze.add_command(code)

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/src/robotcode/analyze/code/cli.py

@@ -19,7 +19,7 @@ from robotcode.robot.config.loader import (
 from robotcode.robot.config.utils import get_config_files
 
 from ..__version__ import __version__
-from ..config import AnalyzeConfig, ExitCodeMask, ModifiersConfig
+from ..config import AnalyzeConfig, CacheConfig, CodeConfig, ExitCodeMask, ModifiersConfig
 from .code_analyzer import CodeAnalyzer, DocumentDiagnosticReport, FolderDiagnosticReport
 
 SEVERITY_COLORS = {
@@ -270,6 +270,18 @@ def _validate_load_library_timeout(ctx: click.Context, param: click.Option, valu
         "Must be > 0. Overrides config file and environment variable when set."
     ),
 )
+@click.option(
+    "--collect-unused/--no-collect-unused",
+    default=None,
+    help="Enable or disable collection of unused keyword and unused variable diagnostics. "
+    "Overrides the config file setting when specified.",
+)
+@click.option(
+    "--cache-namespaces/--no-cache-namespaces",
+    default=None,
+    help="Enable or disable caching of fully analyzed namespace data to disk. "
+    "Can speed up startup for large projects by skipping re-analysis of unchanged files.",
+)
 @click.argument(
     "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
 )
@@ -289,6 +301,8 @@ def code(
     extend_exit_code_mask: ExitCodeMask,
     paths: Tuple[Path],
     load_library_timeout: Optional[int],
+    collect_unused: Optional[bool],
+    cache_namespaces: Optional[bool],
 ) -> None:
     """\
         Performs static code analysis to identify potential issues in the specified *PATHS*. The analysis detects syntax
@@ -393,6 +407,16 @@ def code(
         if load_library_timeout is not None:
             analyzer_config.load_library_timeout = load_library_timeout
 
+        if collect_unused is not None:
+            if analyzer_config.code is None:
+                analyzer_config.code = CodeConfig()
+            analyzer_config.code.collect_unused = collect_unused
+
+        if cache_namespaces is not None:
+            if analyzer_config.cache is None:
+                analyzer_config.cache = CacheConfig()
+            analyzer_config.cache.cache_namespaces = cache_namespaces
+
         app.verbose(f"Using analyzer_config: {analyzer_config}")
         app.verbose(f"Using exit code mask: {mask}")
 
@@ -403,6 +427,11 @@ def code(
             analysis_config=analyzer_config.to_workspace_analysis_config(),
             robot_profile=robot_profile,
             root_folder=root_folder,
+            collect_unused=bool(
+                analyzer_config.code.collect_unused
+                if analyzer_config.code is not None and analyzer_config.code.collect_unused is not None
+                else False
+            ),
         )
         try:
             for e in analyzer.run(paths=paths, filter=filter):

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/src/robotcode/analyze/code/code_analyzer.py

@@ -35,9 +35,11 @@ class CodeAnalyzer(DiagnosticsContext):
         analysis_config: WorkspaceAnalysisConfig,
         robot_profile: RobotBaseProfile,
         root_folder: Optional[Path],
+        collect_unused: bool = False,
     ):
         self.app = app
         self._analysis_config = analysis_config or WorkspaceAnalysisConfig()
+        self._collect_unused = collect_unused
 
         self._robot_profile = robot_profile
         self._root_folder = root_folder if root_folder is not None else Path.cwd()
@@ -62,6 +64,10 @@ class CodeAnalyzer(DiagnosticsContext):
     def analysis_config(self) -> WorkspaceAnalysisConfig:
         return self._analysis_config
 
+    @property
+    def collect_unused(self) -> bool:
+        return self._collect_unused
+
     @property
     def profile(self) -> RobotBaseProfile:
         return self._robot_profile

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/src/robotcode/analyze/code/diagnostics_context.py

@@ -48,6 +48,10 @@ class DiagnosticsContext(ABC):
     @abstractmethod
     def analysis_config(self) -> WorkspaceAnalysisConfig: ...
 
+    @property
+    @abstractmethod
+    def collect_unused(self) -> bool: ...
+
     @property
     @abstractmethod
     def profile(self) -> RobotBaseProfile: ...

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/src/robotcode/analyze/code/robot_framework_language_provider.py

@@ -57,8 +57,8 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
         self.diagnostics_context.diagnostics.folder_analyzers.add(self.analyze_folder)
         self.diagnostics_context.diagnostics.document_analyzers.add(self.analyze_document)
         self.diagnostics_context.diagnostics.document_collectors.add(self.collect_diagnostics)
-        # self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_keywords)
-        # self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_variables)
+        self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_keywords)
+        self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_variables)
 
     def _update_python_path(self) -> None:
         root_path = (
@@ -121,27 +121,20 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
     def collect_diagnostics(self, sender: Any, document: TextDocument) -> Optional[List[Diagnostic]]:
         namespace = self._document_cache.get_namespace(document)
 
-        return self._document_cache.get_diagnostic_modifier(document).modify_diagnostics(namespace.get_diagnostics())
+        return self._document_cache.get_diagnostic_modifier(document).modify_diagnostics(namespace.diagnostics)
 
     def collect_unused_keywords(self, sender: Any, document: TextDocument) -> Optional[List[Diagnostic]]:
+        if not self.diagnostics_context.collect_unused:
+            return None
+
         namespace = self._document_cache.get_namespace(document)
 
-        documents = (
-            [document]
-            if self._document_cache.get_document_type(document) != DocumentType.RESOURCE
-            else self.diagnostics_context.workspace.documents.documents
-        )
+        project_index = self._document_cache.get_project_index(document)
 
         result: List[Diagnostic] = []
 
-        for kw in (namespace.get_library_doc()).keywords.values():
-            has_reference = False
-            for doc in documents:
-                refs = self._document_cache.get_namespace(doc).get_keyword_references()
-                if refs.get(kw):
-                    has_reference = True
-                    break
-            if not has_reference:
+        for kw in namespace.library_doc.keywords.values():
+            if not project_index.find_keyword_references(kw):
                 result.append(
                     Diagnostic(
                         range=kw.name_range,
@@ -156,11 +149,15 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
         return result
 
     def collect_unused_variables(self, sender: Any, document: TextDocument) -> Optional[List[Diagnostic]]:
+        if not self.diagnostics_context.collect_unused:
+            return None
+
         result: List[Diagnostic] = []
 
         namespace = self._document_cache.get_namespace(document)
+        project_index = self._document_cache.get_project_index(document)
 
-        for var, locations in (namespace.get_variable_references()).items():
+        for var, locations in namespace.variable_references.items():
             if var.type in (
                 VariableDefinitionType.LIBRARY_ARGUMENT,
                 VariableDefinitionType.ENVIRONMENT_VARIABLE,
@@ -182,16 +179,7 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
                 )
                 and self._document_cache.get_document_type(document) == DocumentType.RESOURCE
             ):
-                if self.verbose_callback is not None:
-                    self.verbose_callback(f"Checking variable '{var.name}' {var.type} for usage. {document.uri}")
-                    self.verbose_callback(
-                        f"Searching references in {len(self.diagnostics_context.workspace.documents)} documents."
-                    )
-
-                has_reference = any(
-                    len(self._document_cache.get_namespace(doc).get_variable_references().get(var, set())) > 0
-                    for doc in self.diagnostics_context.workspace.documents.documents
-                )
+                has_reference = bool(project_index.find_variable_references(var))
 
             if not has_reference:
                 result.append(

{robotcode_analyze-2.4.0 → robotcode_analyze-2.5.1}/src/robotcode/analyze/config.py

@@ -197,6 +197,21 @@ class CacheConfig(BaseOptions):
         description="Extend the ignore arguments for library settings."
     )
 
+    cache_namespaces: Optional[bool] = field(
+        description="""\
+            Enable or disable caching of fully analyzed namespace data to disk.
+            Can speed up startup for large projects by skipping re-analysis of unchanged files.
+            Defaults to enabled.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.cache]
+            cache_namespaces = false
+            ```
+        """,
+    )
+
 
 class ExitCodeMask(IntFlag):
     NONE = 0
@@ -247,6 +262,20 @@ class CodeConfig(BaseOptions):
     )
     extend_exit_code_mask: Optional[ExitCodeMaskList] = field(description="Extend the exit code mask setting.")
 
+    collect_unused: Optional[bool] = field(
+        description="""\
+            Enables collection of unused keyword and unused variable diagnostics.
+            By default this is disabled. Set to `true` to report unused keywords and variables.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.code]
+            collect_unused = true
+            ```
+        """,
+    )
+
 
 @dataclass
 class AnalyzeConfig(BaseOptions):
@@ -358,6 +387,7 @@ class AnalyzeConfig(BaseOptions):
                     ignored_libraries=self.cache.ignored_libraries or [],
                     ignored_variables=self.cache.ignored_variables or [],
                     ignore_arguments_for_library=self.cache.ignore_arguments_for_library or [],
+                    cache_namespaces=(self.cache.cache_namespaces if self.cache.cache_namespaces is not None else True),
                 )
                 if self.cache is not None
                 else WorkspaceCacheConfig()

robotcode_analyze-2.4.0/src/robotcode/analyze/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.4.0"