kctl-react 0.6.2__py3-none-any.whl

kctl_react/core/compliance/fixes/i18n_fix.py

@@ -0,0 +1,61 @@
+"""Fixer: sync missing i18n keys between en.json and id.json."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def _flatten_keys(d: dict[str, Any], prefix: str = "") -> set[str]:
+    """Flatten nested dict keys to dot notation."""
+    keys: set[str] = set()
+    for k, v in d.items():
+        full = f"{prefix}{k}" if not prefix else f"{prefix}.{k}"
+        if isinstance(v, dict):
+            keys.update(_flatten_keys(v, full))
+        else:
+            keys.add(full)
+    return keys
+
+
+def _set_nested(d: dict[str, Any], dotted_key: str, value: Any) -> None:
+    """Set a nested key using dot notation, creating intermediate dicts."""
+    parts = dotted_key.split(".")
+    for part in parts[:-1]:
+        d = d.setdefault(part, {})
+    d[parts[-1]] = value
+
+
+def fix_i18n(app_path: Path, app_name: str, dry_run: bool = False) -> int:
+    """Add missing keys (as empty strings) to en.json / id.json. Return fix count."""
+    i18n_dir = app_path / "src" / "i18n"
+    en_path = i18n_dir / "en.json"
+    id_path = i18n_dir / "id.json"
+
+    if not en_path.is_file() or not id_path.is_file():
+        return 0
+
+    en_data: dict[str, Any] = json.loads(en_path.read_text(encoding="utf-8"))
+    id_data: dict[str, Any] = json.loads(id_path.read_text(encoding="utf-8"))
+
+    en_keys = _flatten_keys(en_data)
+    id_keys = _flatten_keys(id_data)
+
+    count = 0
+
+    # Keys in en but missing in id
+    for key in sorted(en_keys - id_keys):
+        _set_nested(id_data, key, "")
+        count += 1
+
+    # Keys in id but missing in en
+    for key in sorted(id_keys - en_keys):
+        _set_nested(en_data, key, "")
+        count += 1
+
+    if count > 0 and not dry_run:
+        en_path.write_text(json.dumps(en_data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        id_path.write_text(json.dumps(id_data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+    return count

kctl_react/core/compliance/fixes/imports_fix.py

@@ -0,0 +1,36 @@
+"""Fixer: remove 'use client' directives from .ts/.tsx files."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_USE_CLIENT_RE = re.compile(r'^["\']use client["\']\s*;?\s*\n', re.MULTILINE)
+
+_SKIP_DIRS = {"node_modules", "generated", ".git", "dist", "__pycache__"}
+
+
+def fix_imports(app_path: Path, app_name: str, dry_run: bool = False) -> int:
+    """Remove 'use client' directives. Return count of fixes applied."""
+    src = app_path / "src"
+    if not src.is_dir():
+        return 0
+
+    count = 0
+    for f in src.rglob("*"):
+        if not f.is_file():
+            continue
+        if f.suffix not in (".ts", ".tsx"):
+            continue
+        # Skip excluded directories
+        if any(part in _SKIP_DIRS for part in f.relative_to(src).parts):
+            continue
+
+        text = f.read_text(encoding="utf-8")
+        new_text = _USE_CLIENT_RE.sub("", text)
+        if new_text != text:
+            if not dry_run:
+                f.write_text(new_text, encoding="utf-8")
+            count += 1
+
+    return count

kctl_react/core/compliance/fixes/structure_fix.py

@@ -0,0 +1,20 @@
+"""Fixer: create missing required directories."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from kctl_react.core.compliance.checks.structure import REQUIRED_DIRS
+
+
+def fix_structure(app_path: Path, app_name: str, dry_run: bool = False) -> int:
+    """Create missing required directories. Return count of fixes applied."""
+    src = app_path / "src"
+    count = 0
+    for d in REQUIRED_DIRS:
+        target = src / d
+        if not target.is_dir():
+            if not dry_run:
+                target.mkdir(parents=True, exist_ok=True)
+            count += 1
+    return count

kctl_react/core/compliance/fixes/theme_fix.py

@@ -0,0 +1,29 @@
+"""Fixer: correct theme import path in index.css."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_THEME_IMPORT_RE = re.compile(r'@import\s+["\']@kodemeio/tailwind-config/themes/\w+\.css["\']')
+
+
+def fix_theme(app_path: Path, app_name: str, dry_run: bool = False) -> int:
+    """Fix theme import path in index.css. Return count of fixes applied."""
+    index_css = app_path / "src" / "index.css"
+    if not index_css.is_file():
+        return 0
+
+    text = index_css.read_text(encoding="utf-8")
+    correct_import = f'@import "@kodemeio/tailwind-config/themes/{app_name}.css"'
+
+    if correct_import in text:
+        return 0
+
+    new_text = _THEME_IMPORT_RE.sub(correct_import, text)
+    if new_text != text:
+        if not dry_run:
+            index_css.write_text(new_text, encoding="utf-8")
+        return 1
+
+    return 0

kctl_react/core/compliance/models.py

@@ -0,0 +1,106 @@
+"""Data models for compliance audit results."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+def compute_grade(score: int) -> str:
+    """Convert 0-100 percentage to letter grade."""
+    if score >= 95:
+        return "A+"
+    if score >= 90:
+        return "A"
+    if score >= 80:
+        return "B"
+    if score >= 70:
+        return "C"
+    if score >= 60:
+        return "D"
+    return "F"
+
+
+@dataclass
+class Violation:
+    file: str
+    line: int | None = None
+    message: str = ""
+    fix_hint: str | None = None
+    auto_fixable: bool = False
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "line": self.line,
+            "message": self.message,
+            "fix_hint": self.fix_hint,
+            "auto_fixable": self.auto_fixable,
+        }
+
+
+@dataclass
+class CategoryResult:
+    name: str
+    label: str
+    max_points: int
+    violations: list[Violation] = field(default_factory=list)
+
+    @property
+    def score(self) -> int:
+        """max_points minus len(violations), capped at 0."""
+        return max(0, self.max_points - len(self.violations))
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "label": self.label,
+            "max_points": self.max_points,
+            "score": self.score,
+            "violations": [v.to_dict() for v in self.violations],
+        }
+
+
+@dataclass
+class AppReport:
+    app: str
+    categories: list[CategoryResult] = field(default_factory=list)
+
+    @property
+    def total_score(self) -> int:
+        return sum(c.score for c in self.categories)
+
+    @property
+    def max_score(self) -> int:
+        return sum(c.max_points for c in self.categories)
+
+    @property
+    def grade(self) -> str:
+        """Percentage-based grade: total_score / max_score * 100."""
+        if self.max_score == 0:
+            return "A+"
+        pct = int(self.total_score / self.max_score * 100)
+        return compute_grade(pct)
+
+    @property
+    def total_violations(self) -> int:
+        return sum(len(c.violations) for c in self.categories)
+
+    @property
+    def auto_fixable_count(self) -> int:
+        return sum(1 for c in self.categories for v in c.violations if v.auto_fixable)
+
+    @property
+    def needs_review_count(self) -> int:
+        return self.total_violations - self.auto_fixable_count
+
+    def to_dict(self) -> dict:
+        return {
+            "app": self.app,
+            "total_score": self.total_score,
+            "max_score": self.max_score,
+            "grade": self.grade,
+            "total_violations": self.total_violations,
+            "auto_fixable_count": self.auto_fixable_count,
+            "needs_review_count": self.needs_review_count,
+            "categories": [c.to_dict() for c in self.categories],
+        }

kctl_react/core/config.py

@@ -0,0 +1,201 @@
+"""Config management — delegates to kctl-lib with react-specific ServiceConfig.
+
+Core I/O (load_raw_config / save_raw_config) uses module-level CONFIG_DIR /
+CONFIG_FILE so that tests can monkeypatch those names.  is_service_scoped and
+ConfigFile are re-used from kctl_lib; all file-touching functions are local.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+from kctl_lib.config import ConfigFile, is_service_scoped
+from pydantic import BaseModel
+
+SERVICE_KEY = "react"
+ENV_PREFIX = "KCTL_REACT"
+
+CONFIG_DIR = Path.home() / ".config" / "kodemeio"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+__all__ = [
+    "CONFIG_DIR",
+    "CONFIG_FILE",
+    "ServiceConfig",
+    "get_all_services_in_profile",
+    "get_default_profile",
+    "get_profile_names",
+    "get_service_config",
+    "load_config",
+    "load_raw_config",
+    "remove_profile",
+    "resolve_active_profile_name",
+    "resolve_project_root",
+    "save_raw_config",
+    "set_default_profile",
+    "set_service_config",
+]
+
+
+class ServiceConfig(BaseModel):
+    """Service-specific config within a profile."""
+
+    project_root: str = ""
+    api_url: str = ""
+    odoo_url: str = ""
+    odoo_db: str = ""
+
+
+def load_raw_config() -> dict[str, Any]:
+    """Load raw YAML config from disk."""
+    import kctl_react.core.config as _self
+
+    cf = _self.CONFIG_FILE
+    if not cf.exists():
+        return {}
+    try:
+        with open(cf) as f:
+            return yaml.safe_load(f) or {}
+    except (yaml.YAMLError, OSError) as e:
+        print(f"WARN: Cannot read {cf}: {e}", file=sys.stderr)
+        return {}
+
+
+def save_raw_config(data: dict[str, Any]) -> None:
+    """Write raw config dict to YAML file."""
+    import kctl_react.core.config as _self
+
+    cd = _self.CONFIG_DIR
+    cf = _self.CONFIG_FILE
+    cd.mkdir(parents=True, exist_ok=True)
+    with open(cf, "w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+
+def load_config() -> ConfigFile:
+    """Load and validate the config file."""
+    data = load_raw_config()
+    return ConfigFile(
+        default_profile=data.get("default_profile", "default"),
+        profiles=data.get("profiles", {}),
+    )
+
+
+def get_service_config(profile_name: str) -> ServiceConfig:
+    """Get the 'react' service config from a profile."""
+    cfg = load_config()
+    profile_data = cfg.profiles.get(profile_name, {})
+    if not profile_data:
+        return ServiceConfig()
+    if is_service_scoped(profile_data):
+        svc_data = profile_data.get(SERVICE_KEY, {})
+        if isinstance(svc_data, dict):
+            return ServiceConfig(**{k: v for k, v in svc_data.items() if k in ServiceConfig.model_fields})
+        return ServiceConfig()
+    else:
+        return ServiceConfig(**{k: v for k, v in profile_data.items() if k in ServiceConfig.model_fields})
+
+
+def set_service_config(profile_name: str, svc_config: ServiceConfig) -> None:
+    """Set the 'react' service config within a profile."""
+    data = load_raw_config()
+    if "profiles" not in data:
+        data["profiles"] = {}
+    if profile_name not in data["profiles"]:
+        data["profiles"][profile_name] = {}
+    profile = data["profiles"][profile_name]
+    if not is_service_scoped(profile):
+        old_data = dict(profile)
+        profile.clear()
+        profile[SERVICE_KEY] = old_data
+    svc_data = svc_config.model_dump(exclude_defaults=False)
+    for key in list(svc_data.keys()):
+        if not svc_data.get(key):
+            svc_data.pop(key, None)
+    profile[SERVICE_KEY] = svc_data
+    save_raw_config(data)
+
+
+def get_profile_names() -> list[str]:
+    """Return all profile names."""
+    return list(load_config().profiles.keys())
+
+
+def get_all_services_in_profile(profile_name: str) -> dict[str, dict[str, Any]]:
+    """Return all service configs within a profile."""
+    cfg = load_config()
+    profile_data = cfg.profiles.get(profile_name, {})
+    if is_service_scoped(profile_data):
+        return {k: v for k, v in profile_data.items() if isinstance(v, dict)}
+    return {}
+
+
+def get_default_profile() -> str:
+    """Return the default profile name."""
+    return load_config().default_profile
+
+
+def set_default_profile(name: str) -> None:
+    """Set the default profile name."""
+    data = load_raw_config()
+    data["default_profile"] = name
+    save_raw_config(data)
+
+
+def remove_profile(name: str) -> None:
+    """Remove a profile by name."""
+    data = load_raw_config()
+    profiles = data.get("profiles", {})
+    profiles.pop(name, None)
+    if data.get("default_profile") == name:
+        data["default_profile"] = next(iter(profiles), "default")
+    save_raw_config(data)
+
+
+def resolve_active_profile_name(profile_name: str | None = None) -> str:
+    """Resolve active profile: explicit > env > default."""
+    if profile_name:
+        return profile_name
+    if env := os.environ.get(f"{ENV_PREFIX}_PROFILE"):
+        return env
+    return get_default_profile()
+
+
+def resolve_project_root(
+    profile_name: str | None = None,
+    root_override: str | None = None,
+) -> Path:
+    """Resolve the monorepo project root.
+
+    Priority:
+    1. CLI --root flag
+    2. KCTL_REACT_ROOT env var
+    3. Profile config project_root
+    4. Auto-detect from CWD (walk up to find turbo.json)
+    """
+    # 1. CLI override
+    if root_override:
+        return Path(root_override)
+
+    # 2. Env var
+    if env_root := os.environ.get("KCTL_REACT_ROOT"):
+        return Path(env_root)
+
+    # 3. Profile config
+    pname = resolve_active_profile_name(profile_name)
+    svc = get_service_config(pname)
+    if svc.project_root:
+        return Path(svc.project_root)
+
+    # 4. Auto-detect from CWD
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / "turbo.json").exists() and (parent / "apps").is_dir():
+            return parent
+
+    # Fallback to CWD
+    return cwd

kctl_react/core/discovery.py

@@ -0,0 +1,185 @@
+"""Auto-discover apps and packages from the monorepo filesystem.
+
+Scans apps/ and packages/ directories, reads package.json files,
+and extracts metadata (name, version, port, description).
+Works with any Turbo + pnpm monorepo, not just Kodemeio.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+
+def _extract_port(dev_script: str) -> int:
+    """Extract port number from a vite dev script like 'vite --port 4004'."""
+    match = re.search(r"--port\s+(\d+)", dev_script)
+    if match:
+        return int(match.group(1))
+    # Try PORT= env var pattern
+    match = re.search(r"PORT=(\d+)", dev_script)
+    if match:
+        return int(match.group(1))
+    return 0
+
+
+def detect_framework(app_dir: Path) -> str:
+    """Detect whether an app uses Vite or Next.js.
+
+    Returns 'nextjs' if next.config.ts/js/mjs exists, otherwise 'vite'.
+    """
+    for name in ("next.config.ts", "next.config.js", "next.config.mjs"):
+        if (app_dir / name).exists():
+            return "nextjs"
+    return "vite"
+
+
+def _read_pkg_json(path: Path) -> dict:
+    """Safely read and parse a package.json file."""
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return {}
+
+
+APP_TYPE_DIRS = ("spa", "web", "api")
+
+
+def discover_apps(root: Path) -> dict[str, dict[str, Any]]:
+    """Discover apps from the apps/ directory.
+
+    Scans apps/{spa,web,api}/ subdirectories for nested app structure.
+    Falls back to flat apps/ scanning for legacy repos.
+
+    Returns a dict like:
+      {"sfa": {"port": 4004, "name": "Sales Force Automation", "package": "@kodemeio/sfa", "type": "spa", "path": Path(...)}}
+
+    Works with any Turbo monorepo — reads package.json for metadata.
+    """
+    apps_dir = root / "apps"
+    if not apps_dir.is_dir():
+        return {}
+
+    registry: dict[str, dict[str, Any]] = {}
+
+    # Try nested structure first: apps/{spa,web,api}/{app}
+    found_nested = False
+    for type_name in APP_TYPE_DIRS:
+        type_dir = apps_dir / type_name
+        if not type_dir.is_dir():
+            continue
+
+        found_nested = True
+        for app_dir in sorted(type_dir.iterdir()):
+            if not app_dir.is_dir():
+                continue
+
+            pkg_file = app_dir / "package.json"
+            if not pkg_file.exists():
+                continue
+
+            pkg = _read_pkg_json(pkg_file)
+            if not pkg:
+                continue
+
+            dev_script = pkg.get("scripts", {}).get("dev", "")
+            port = _extract_port(dev_script)
+            pkg_name = pkg.get("name", app_dir.name)
+            description = pkg.get("description", "")
+
+            registry[app_dir.name] = {
+                "port": port,
+                "name": description or app_dir.name,
+                "package": pkg_name,
+                "framework": detect_framework(app_dir),
+                "type": type_name,
+                "path": app_dir,
+            }
+
+    if found_nested:
+        return registry
+
+    # Legacy fallback: flat apps/{app} structure
+    for app_dir in sorted(apps_dir.iterdir()):
+        if not app_dir.is_dir():
+            continue
+
+        pkg_file = app_dir / "package.json"
+        if not pkg_file.exists():
+            continue
+
+        pkg = _read_pkg_json(pkg_file)
+        if not pkg:
+            continue
+
+        dev_script = pkg.get("scripts", {}).get("dev", "")
+        port = _extract_port(dev_script)
+        pkg_name = pkg.get("name", app_dir.name)
+        description = pkg.get("description", "")
+
+        registry[app_dir.name] = {
+            "port": port,
+            "name": description or app_dir.name,
+            "package": pkg_name,
+            "framework": detect_framework(app_dir),
+            "type": "spa",
+            "path": app_dir,
+        }
+
+    return registry
+
+
+def get_app_dir(root: Path, app_name: str, registry: dict[str, dict[str, Any]] | None = None) -> Path:
+    """Get the filesystem path for an app, using registry or fallback scanning."""
+    if registry and app_name in registry:
+        return registry[app_name]["path"]
+    # Fallback: scan for it
+    for type_name in APP_TYPE_DIRS:
+        candidate = root / "apps" / type_name / app_name
+        if candidate.is_dir():
+            return candidate
+    # Legacy fallback for backwards compat
+    return root / "apps" / app_name
+
+
+def discover_packages(root: Path) -> list[str]:
+    """Discover shared packages from the packages/ directory.
+
+    Returns a list of package directory names: ["core", "ui", "tailwind-config", ...]
+    """
+    packages_dir = root / "packages"
+    if not packages_dir.is_dir():
+        return []
+
+    result: list[str] = []
+    for pkg_dir in sorted(packages_dir.iterdir()):
+        if not pkg_dir.is_dir():
+            continue
+        if (pkg_dir / "package.json").exists():
+            result.append(pkg_dir.name)
+
+    return result
+
+
+def get_monorepo_scope(root: Path) -> str:
+    """Detect the npm scope (e.g. '@kodemeio' or '@kontenos') from root package.json.
+
+    Falls back to reading the first app's package name.
+    """
+    # Try root package.json
+    root_pkg = _read_pkg_json(root / "package.json")
+    root_name = root_pkg.get("name", "")
+    if root_name.startswith("@"):
+        return root_name.split("/")[0]
+
+    # Try first app
+    apps = discover_apps(root)
+    for info in apps.values():
+        pkg_name = info.get("package", "")
+        if pkg_name.startswith("@"):
+            return pkg_name.split("/")[0]
+
+    # Try pnpm-workspace.yaml for name hints
+    return ""

kctl_react/core/exceptions.py

@@ -0,0 +1,17 @@
+"""Exception hierarchy — re-exported from kctl-lib."""
+
+from kctl_lib.exceptions import (
+    AppNotFoundError,
+    CommandError,
+    ConfigError,
+    KctlError,
+    NotFoundError,
+)
+
+__all__ = [
+    "AppNotFoundError",
+    "CommandError",
+    "ConfigError",
+    "KctlError",
+    "NotFoundError",
+]