feat: Implement BCASL Studio application with UI and core functionality

- Added main application logic in app.py to initialize the BCASL Studio.
- Created configuration management in config.py to handle YAML and JSON formats.
- Developed plugin discovery and management in plugins.py.
- Implemented report summarization in report.py for plugin execution results.
- Added runner functionality in runner.py to execute BCASL with specified configurations.
- Designed the main window UI in studio.ui and integrated it with the application.
- Enhanced user experience with workspace and plugin directory selection.
- Implemented theme application based on user preferences.
- Added logging and error handling throughout the application for better debugging.

Author: PyCompiler ARK++

bcasl/only_mod/app.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QIcon
+
+from .widgets.main_window import BCASLStudioWindow
+
+
+APP_NAME = "BCASL Studio"
+
+
+def _apply_theme(app: QApplication) -> None:
+    """Load a QSS theme from the repo's themes/ directory.
+    Priority: env BCASL_THEME -> dark.qss -> light.qss. Safe no-op on errors.
+    """
+    try:
+        root = Path(__file__).resolve().parents[2]
+        themes_dir = root / "themes"
+        if not themes_dir.is_dir():
+            return
+        chosen = os.environ.get("BCASL_THEME", "").strip()
+        candidates = [chosen] if chosen else ["dark.qss", "light.qss"]
+        for name in candidates:
+            if not name:
+                continue
+            p = themes_dir / name
+            if p.is_file():
+                qss = p.read_text(encoding="utf-8")
+                app.setStyleSheet(qss)
+                return
+    except Exception:
+        pass
+
+
+def run(argv: list[str]) -> int:
+    # Minimal environment sanity
+    os.environ.setdefault("PYTHONUTF8", "1")
+    os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+
+    app = QApplication(argv)
+    app.setApplicationName(APP_NAME)
+    # Try to reuse repo logo if present
+    try:
+        root = Path(__file__).resolve().parents[2]
+        icon = root / "logo" / "logo.png"
+        if icon.is_file():
+            app.setWindowIcon(QIcon(str(icon)))
+    except Exception:
+        pass
+
+    _apply_theme(app)
+
+    w = BCASLStudioWindow()
+    w.show()
+    rc = app.exec()
+    return int(rc) if isinstance(rc, int) else 0

bcasl/only_mod/core/config.py

@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+import json
+import yaml
+
+DEFAULT_EXCLUDE = [
+    "**/__pycache__/**",
+    "**/*.pyc",
+    ".git/**",
+    "venv/**",
+    ".venv/**",
+]
+
+DEFAULT_INCLUDE = ["**/*.py"]
+
+
+@dataclass
+class BCASLConfig:
+    file_patterns: list[str] = field(default_factory=lambda: list(DEFAULT_INCLUDE))
+    exclude_patterns: list[str] = field(default_factory=lambda: list(DEFAULT_EXCLUDE))
+    options: dict[str, Any] = field(
+        default_factory=lambda: {
+            "plugin_timeout_s": 0.0,
+            "sandbox": True,
+            "plugin_parallelism": 0,
+            "iter_files_cache": True,
+            "env": {},
+        }
+    )
+    plugins: dict[str, Any] = field(default_factory=dict)
+    plugin_order: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        d = {
+            "file_patterns": list(self.file_patterns),
+            "exclude_patterns": list(self.exclude_patterns),
+            "options": dict(self.options),
+            "plugins": dict(self.plugins),
+            "plugin_order": list(self.plugin_order),
+        }
+        # Never persist global 'enabled' flag; only per-plugin enabled
+        try:
+            d["options"].pop("enabled", None)
+        except Exception:
+            pass
+        return d
+
+
+def read_yaml(path: Path) -> dict[str, Any]:
+    try:
+        return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except Exception:
+        return {}
+
+
+def write_yaml(path: Path, data: dict[str, Any]) -> None:
+    path.write_text(yaml.safe_dump(data, sort_keys=False, allow_unicode=True), encoding="utf-8")
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def load_config(workspace: Path) -> BCASLConfig:
+    """Load bcasl.yml if present; migrate legacy JSON to YAML; otherwise return defaults."""
+    yml = workspace / "bcasl.yml"
+    legacy = [workspace / "bcasl.json", workspace / ".bcasl.json"]
+    data: dict[str, Any] = {}
+    if yml.is_file():
+        data = read_yaml(yml)
+    else:
+        # migrate JSON if exists
+        for p in legacy:
+            if p.is_file():
+                data = read_json(p)
+                break
+        if data:
+            # persist migration
+            try:
+                write_yaml(yml, data)
+            except Exception:
+                pass
+    cfg = BCASLConfig()
+    if isinstance(data, dict) and data:
+        cfg.file_patterns = list(data.get("file_patterns", cfg.file_patterns))
+        cfg.exclude_patterns = list(data.get("exclude_patterns", cfg.exclude_patterns))
+        opts = dict(data.get("options", {})) if isinstance(data.get("options"), dict) else {}
+        # ensure no persisted global enabled
+        opts.pop("enabled", None)
+        cfg.options.update(opts)
+        cfg.plugins = dict(data.get("plugins", {}))
+        cfg.plugin_order = list(data.get("plugin_order", []))
+    return cfg
+
+
+def save_config(workspace: Path, cfg: BCASLConfig) -> None:
+    yml = workspace / "bcasl.yml"
+    write_yaml(yml, cfg.to_dict())

bcasl/only_mod/core/plugins.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from bcasl.tagging import compute_tag_order
+
+
+def discover_plugins(plugins_dir: Path) -> dict[str, dict[str, Any]]:
+    """Return meta mapping id -> {name, version, description, author, tags}."""
+    meta: dict[str, dict[str, Any]] = {}
+    try:
+        import importlib.util as _ilu
+        import sys as _sys
+
+        for pkg_dir in sorted(plugins_dir.iterdir(), key=lambda p: p.name):
+            try:
+                if not pkg_dir.is_dir():
+                    continue
+                init_py = pkg_dir / "__init__.py"
+                if not init_py.exists():
+                    continue
+                mod_name = f"bcasl_meta_only_{pkg_dir.name}"
+                spec = _ilu.spec_from_file_location(
+                    mod_name, str(init_py), submodule_search_locations=[str(pkg_dir)]
+                )
+                if spec is None or spec.loader is None:
+                    continue
+                module = _ilu.module_from_spec(spec)
+                _sys.modules[mod_name] = module
+                spec.loader.exec_module(module)  # type: ignore[attr-defined]
+                reg = getattr(module, "bcasl_register", None)
+                if not callable(reg):
+                    continue
+                # lightweight registration to extract meta
+                from bcasl.executor import BCASL
+
+                mgr = BCASL(plugins_dir, config={}, sandbox=False, plugin_timeout_s=0.0)
+                reg(mgr)
+                for pid, rec in getattr(mgr, "_registry", {}).items():
+                    try:
+                        plg = rec.plugin
+                        tags = []
+                        try:
+                            tags0 = getattr(plg.meta, "tags", ())
+                            tags = [str(x).strip().lower() for x in tags0 if str(x).strip()]
+                        except Exception:
+                            tags = []
+                        meta[plg.meta.id] = {
+                            "id": plg.meta.id,
+                            "name": plg.meta.name,
+                            "version": plg.meta.version,
+                            "description": plg.meta.description,
+                            "author": plg.meta.author,
+                            "tags": tags,
+                        }
+                    except Exception:
+                        continue
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return meta
+
+
+def compute_initial_order(meta_map: dict[str, dict[str, Any]]) -> list[str]:
+    try:
+        return list(compute_tag_order(meta_map))
+    except Exception:
+        return sorted(meta_map.keys())

bcasl/only_mod/core/report.py

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+
+@dataclass
+class PluginResult:
+    plugin_id: str
+    success: bool
+    error: str
+    duration_ms: float
+
+
+def summarize(report: Iterable[Any]) -> dict[str, Any]:
+    ok = 0
+    fail = 0
+    total_ms = 0.0
+    for item in report:
+        ok += 1 if getattr(item, "success", False) else 0
+        fail += 0 if getattr(item, "success", False) else 1
+        total_ms += float(getattr(item, "duration_ms", 0.0))
+    return {"ok": ok, "fail": fail, "total_ms": total_ms}

bcasl/only_mod/core/runner.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from bcasl.executor import BCASL
+from bcasl.Base import PreCompileContext
+
+
+def run_bcasl(workspace: Path, plugins_dir: Path, cfg: dict[str, Any]) -> Optional[object]:
+    """Synchronous run of BCASL with given config dict (already merged)."""
+    try:
+        manager = BCASL(workspace, config=cfg, plugin_timeout_s=float(cfg.get("options", {}).get("plugin_timeout_s", 0.0)))
+        loaded, errors = manager.load_plugins_from_directory(plugins_dir)
+        # apply enables/priorities
+        pmap = cfg.get("plugins", {}) if isinstance(cfg, dict) else {}
+        if isinstance(pmap, dict):
+            for pid, val in pmap.items():
+                try:
+                    enabled = (
+                        val if isinstance(val, bool) else bool((val or {}).get("enabled", True))
+                    )
+                    if not enabled:
+                        manager.disable_plugin(pid)
+                except Exception:
+                    pass
+                try:
+                    if isinstance(val, dict) and "priority" in val:
+                        manager.set_priority(pid, int(val.get("priority", 0)))
+                except Exception:
+                    pass
+        order_list = list(cfg.get("plugin_order", [])) if isinstance(cfg, dict) else []
+        if order_list:
+            for idx, pid in enumerate(order_list):
+                try:
+                    manager.set_priority(pid, int(idx))
+                except Exception:
+                    pass
+        report = manager.run_pre_compile(PreCompileContext(workspace, config=cfg))
+        return report
+    except Exception:
+        return None

bcasl/only_mod/main.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+from .app import run
+
+
+if __name__ == "__main__":
+    sys.exit(run(sys.argv))