Add fine_system_claude_code extension; fix lint bridge file-target dispatch; remove pyrefly from fine_python_lint

- Add extensions/fine_system_claude_code: InstallClaudeCodeHandler
  downloads and runs the Claude Code native installer (shell on Unix,
  PowerShell on Windows), skips if already installed, and reports
  installed/skipped/failed via SetupSystemRunResult.

- Fix LintInspectCodeBridgeHandler to correctly handle InspectCodeTarget.FILES:
  group requested files by known project before dispatching per-project
  LintAction runs (previously all projects were linted regardless of target).
  Warn via user_messenger when no files matched a known project.
  Add debug logging for project dispatch and partial result forwarding.

- Remove pyrefly handler from fine_python_lint preset (lint_python_files
  and its extension dependency). Add fine_lint as an explicit preset
  dependency of fine_python_lint. Add PLC0415 (import-outside-top-level)
  to ruff extend_select.

Author: Aksem

extensions/fine_system_claude_code/.gitignore

@@ -0,0 +1,5 @@
+.venvs
+build/
+*.egg-info/
+__pycache__
+finecode_config_dump/

extensions/fine_system_claude_code/fine_system_claude_code/__init__.py

@@ -0,0 +1,9 @@
+from fine_system_claude_code.install_claude_code_handler import (
+    InstallClaudeCodeHandler,
+    InstallClaudeCodeHandlerConfig,
+)
+
+__all__ = [
+    "InstallClaudeCodeHandler",
+    "InstallClaudeCodeHandlerConfig",
+]

extensions/fine_system_claude_code/fine_system_claude_code/install_claude_code_handler.py

@@ -0,0 +1,92 @@
+import dataclasses
+import shlex
+import shutil
+import sys
+import tempfile
+
+from finecode_extension_api import code_action
+from finecode_extension_api.interfaces import icommandrunner, ihttpclient, ilogger
+from fine_system_setup.setup_system_action import (
+    SetupSystemAction,
+    SetupSystemRunContext,
+    SetupSystemRunPayload,
+    SetupSystemRunResult,
+)
+
+_TOOL_NAME = "claude-code"
+_INSTALL_SH_URL = "https://claude.ai/install.sh"
+_INSTALL_PS1_URL = "https://claude.ai/install.ps1"
+
+
+@dataclasses.dataclass
+class InstallClaudeCodeHandlerConfig(code_action.ActionHandlerConfig): ...
+
+
+class InstallClaudeCodeHandler(
+    code_action.ActionHandler[
+        SetupSystemAction,
+        InstallClaudeCodeHandlerConfig,
+    ]
+):
+    """Install the Claude Code CLI via the native installer if not already present."""
+
+    def __init__(
+        self,
+        logger: ilogger.ILogger,
+        command_runner: icommandrunner.ICommandRunner,
+        http_client: ihttpclient.IHttpClient,
+    ) -> None:
+        self.logger = logger
+        self.command_runner = command_runner
+        self.http_client = http_client
+
+    async def run(
+        self,
+        payload: SetupSystemRunPayload,
+        run_context: SetupSystemRunContext,
+    ) -> SetupSystemRunResult:
+        if shutil.which("claude") is not None:
+            self.logger.info("claude already installed, skipping")
+            return SetupSystemRunResult(skipped=[_TOOL_NAME])
+
+        if sys.platform == "win32":
+            url = _INSTALL_PS1_URL
+            suffix = ".ps1"
+        else:
+            url = _INSTALL_SH_URL
+            suffix = ".sh"
+
+        self.logger.info(f"Downloading installer from {url}")
+        async with run_context.progress("Installing claude-code", total=2) as progress:
+            await progress.report("Downloading installer")
+            async with self.http_client.session() as session:
+                response = await session.get(url)
+                response.raise_for_status()
+                script_content = response.text
+
+            with tempfile.NamedTemporaryFile(mode="w", suffix=suffix, delete_on_close=False) as f:
+                f.write(script_content)
+                script_path = f.name
+                f.close()  # flush and release the file before the subprocess opens it
+
+                if sys.platform == "win32":
+                    cmd = shlex.join(
+                        ["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", script_path]
+                    )
+                else:
+                    cmd = shlex.join(["bash", script_path])
+
+                self.logger.info(f"Running installer: {cmd}")
+                await progress.advance(1, "Running installer")
+                process = await self.command_runner.run(cmd)
+                await process.wait_for_end()
+            await progress.advance(1)
+
+        exit_code = process.get_exit_code()
+        if exit_code != 0:
+            error = process.get_error_output().strip() or process.get_output().strip()
+            self.logger.error(f"Install failed: {error}")
+            return SetupSystemRunResult(failed=[f"{_TOOL_NAME}: {error}"])
+
+        self.logger.info("claude-code installed successfully")
+        return SetupSystemRunResult(installed=[_TOOL_NAME])

extensions/fine_system_claude_code/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "fine_system_claude_code"
+version = "0.1.0a0"
+description = "FineCode handler to install the Claude Code CLI"
+authors = [{ name = "Vladyslav Hnatiuk", email = "aders1234@gmail.com" }]
+requires-python = ">=3.11, < 3.15"
+dependencies = ["finecode_extension_api~=0.4.0a0", "fine_system_setup~=0.1.0a0"]
+
+[dependency-groups]
+dev_workspace = ["finecode~=0.4.0a0", "finecode_dev_common_preset~=0.3.0a0"]
+
+[tool.finecode]
+presets = [{ source = "finecode_dev_common_preset" }]
+
+[tool.setuptools]
+packages = ["fine_system_claude_code"]

extensions/fine_system_claude_code/setup.py

@@ -0,0 +1,66 @@
+import atexit
+import shutil
+import sys
+import tempfile
+
+from setuptools import setup
+from setuptools.command.build import build
+from setuptools.command.build_ext import build_ext
+from setuptools.command.build_py import build_py
+from setuptools.command.egg_info import egg_info
+
+
+_TEMP_BUILD_DIR = None
+
+
+def get_temp_build_dir(pkg_name):
+    global _TEMP_BUILD_DIR
+    if _TEMP_BUILD_DIR is None:
+        _TEMP_BUILD_DIR = tempfile.mkdtemp(prefix=f"{pkg_name}_build_")
+        atexit.register(lambda: shutil.rmtree(_TEMP_BUILD_DIR, ignore_errors=True))
+    return _TEMP_BUILD_DIR
+
+
+class TempDirBuildMixin:
+    def initialize_options(self):
+        super().initialize_options()
+        temp_dir = get_temp_build_dir(self.distribution.get_name())
+        self.build_base = temp_dir
+
+
+class TempDirEggInfoMixin:
+    def initialize_options(self):
+        super().initialize_options()
+        temp_dir = get_temp_build_dir(self.distribution.get_name())
+        self.egg_base = temp_dir
+
+
+class CustomBuild(TempDirBuildMixin, build):
+    pass
+
+
+class CustomBuildPy(TempDirBuildMixin, build_py):
+    pass
+
+
+class CustomBuildExt(TempDirBuildMixin, build_ext):
+    pass
+
+
+class CustomEggInfo(TempDirEggInfoMixin, egg_info):
+    def initialize_options(self):
+        if "--editable" in sys.argv or "-e" in sys.argv:
+            egg_info.initialize_options(self)
+        else:
+            super().initialize_options()
+
+
+setup(
+    name="fine_system_claude_code",
+    cmdclass={
+        "build": CustomBuild,
+        "build_py": CustomBuildPy,
+        "build_ext": CustomBuildExt,
+        "egg_info": CustomEggInfo,
+    },
+)

presets/fine_lint/fine_lint/lint_inspect_code_bridge_handler.py

@@ -2,17 +2,20 @@
 import dataclasses
 import pathlib
 
+from loguru import logger as loguru_logger
 from finecode_extension_api import code_action
 from fine_inspect_code.inspect_code_action import (
     InspectCodeAction,
     InspectCodeRunPayload,
     InspectCodeRunContext,
     InspectCodeRunResult,
+    InspectCodeTarget,
 )
 from fine_lint.lint_action import LintAction, LintRunPayload, LintTarget
-from finecode_extension_api.interfaces import iworkspaceactionrunner, iworkspaceinfoprovider, ilogger
+from finecode_extension_api.interfaces import iworkspaceactionrunner, iworkspaceinfoprovider, ilogger, iuser_messenger
 from finecode_extension_api.interfaces.iworkspaceinfoprovider import actionable_project_paths
-from finecode_extension_api.resource_uri import resource_uri_to_path
+from finecode_extension_api.resource_uri import resource_uri_to_path, path_to_resource_uri
+from finecode_extension_api.workspace_utils import group_files_by_project
 
 
 @dataclasses.dataclass
@@ -29,10 +32,12 @@ def __init__(
         workspace_action_runner: iworkspaceactionrunner.IWorkspaceActionRunner,
         workspace_info_provider: iworkspaceinfoprovider.IWorkspaceInfoProvider,
         logger: ilogger.ILogger,
+        user_messenger: iuser_messenger.IUserMessenger,
     ) -> None:
         self.workspace_action_runner = workspace_action_runner
         self.workspace_info_provider = workspace_info_provider
         self.logger = logger
+        self.user_messenger = user_messenger
 
     async def _run_lint_for_project(
         self,
@@ -41,6 +46,10 @@ async def _run_lint_for_project(
         run_meta: code_action.RunActionMeta,
         partial_result_sender: code_action.PartialResultSender,
     ) -> None:
+        self.logger.debug(
+            f"LintInspectCodeBridgeHandler: running LintAction for project={project_path}"
+            f" file_paths={payload.file_paths}"
+        )
         results = await self.workspace_action_runner.run_action_in_projects(
             action_type=LintAction,
             payload=LintRunPayload(
@@ -51,26 +60,49 @@ async def _run_lint_for_project(
             meta=run_meta,
             project_paths=[project_path],
         )
-        for result in results.values():
+        loguru_logger.debug(
+            f"LintInspectCodeBridgeHandler: LintAction returned {len(results)} project results"
+            f" projects={list(results.keys())}"
+        )
+        for proj_path, result in results.items():
+            loguru_logger.debug(
+                f"LintInspectCodeBridgeHandler: sending partial result for proj_path={proj_path}"
+                f" messages keys={list(result.messages.keys())}"
+            )
             await partial_result_sender.send(InspectCodeRunResult(messages=result.messages))
 
     async def run(
         self,
         payload: InspectCodeRunPayload,
         run_context: InspectCodeRunContext,
     ) -> None:
-        project_paths = (
-            [resource_uri_to_path(uri) for uri in payload.project_paths]
-            if payload.project_paths is not None
-            else actionable_project_paths(await self.workspace_info_provider.get_workspace_projects())
-        )
+        if payload.project_paths is not None:
+            project_paths = [resource_uri_to_path(uri) for uri in payload.project_paths]
+        else:
+            project_paths = actionable_project_paths(await self.workspace_info_provider.get_workspace_projects())
 
+        if payload.target == InspectCodeTarget.FILES:
+            if not payload.file_paths:
+                return
+            file_abs_paths = [resource_uri_to_path(uri) for uri in payload.file_paths]
+            project_to_files = group_files_by_project(file_abs_paths, project_paths)
+            tasks = [
+                (project_path, dataclasses.replace(payload, file_paths=[path_to_resource_uri(f) for f in files]))
+                for project_path, files in project_to_files.items()
+            ]
+            if not tasks:
+                self.user_messenger.warning(
+                    f"LintInspectCodeBridgeHandler: none of the requested files matched a known "
+                    f"project — no lint will run. file_paths={payload.file_paths}"
+                )
+        else:
+            tasks = [(project_path, payload) for project_path in project_paths]
         async with asyncio.TaskGroup() as tg:
-            for project_path in project_paths:
+            for project_path, project_payload in tasks:
                 tg.create_task(
                     self._run_lint_for_project(
                         project_path,
-                        payload,
+                        project_payload,
                         run_context.meta,
                         run_context.partial_result_sender,
                     )

presets/fine_python_lint/fine_python_lint/preset.toml

@@ -1,3 +1,6 @@
+[tool.finecode]
+presets = [{ source = "fine_lint" }]
+
 [tool.finecode.action.lint_python_files]
 source = "fine_python_lang.LintPythonFilesAction"
 handlers = [
@@ -7,9 +10,6 @@ handlers = [
     { name = "flake8", source = "fine_python_flake8.Flake8LintFilesHandler", env = "dev_no_runtime", dependencies = [
         "fine_python_flake8~=0.3.0a0",
     ] },
-    { name = "pyrefly", source = "fine_python_pyrefly.PyreflyLintFilesHandler", env = "dev_no_runtime", dependencies = [
-        "fine_python_pyrefly[jsonrpc]~=0.2.0a0",
-    ] },
 ]
 
 [tool.finecode.action.get_lint_fixes_python_files]
@@ -26,12 +26,12 @@ dependencies_override = ["ruff==0.15.*"]
 [tool.finecode.extension.fine_python_flake8]
 dependencies_override = ["flake8==7.3.*"]
 
-[tool.finecode.extension.fine_python_pyrefly]
-dependencies_override = ["pyrefly==0.64.*"]
-
 [[tool.finecode.action_handler]]
 source = "fine_python_ruff.RuffLintFilesHandler"
-config.extend_select = ["B", "I"]
+# PLC0415 (import-outside-top-level): Checks for import statements outside of a module's
+#                                     top-level scope, such as within a function or
+#                                     class definition.
+config.extend_select = ["B", "I", "PLC0415"]
 
 # flake8 is used only for custom rules, all standard rules are checked by ruff, but
 # keep flake8 configuration if someone activates some rules or uses flake8 config