realtimex-deeptutor 0.5.0.post2__py3-none-any.whl → 0.5.0.post3__py3-none-any.whl

scripts/sync_prompts_from_en.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Semi-automatic sync of prompt structure from prompts/en to prompts/zh|prompts/cn.
+
+Behavior (safe by default):
+- Dry-run: prints what would be added
+- With --write: adds missing keys to zh/cn files without overwriting existing values
+- With --create-missing-files: creates missing zh/cn files using the en structure
+
+NOTE: This tool does NOT translate. It inserts TODO markers to be manually rewritten in Chinese.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+from typing import Any
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+AGENTS_DIR = PROJECT_ROOT / "src" / "agents"
+
+
+def _load_yaml(path: Path) -> Any:
+    with open(path, encoding="utf-8") as f:
+        return yaml.safe_load(f) or {}
+
+
+def _dump_yaml(path: Path, obj: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        yaml.safe_dump(obj, f, allow_unicode=True, sort_keys=False)
+
+
+def _merge_missing(en_obj: Any, zh_obj: Any) -> tuple[Any, int]:
+    """
+    Add missing keys from en_obj into zh_obj without overwriting existing zh content.
+    Returns (new_obj, added_count).
+    """
+    added = 0
+
+    if isinstance(en_obj, dict):
+        if not isinstance(zh_obj, dict):
+            zh_obj = {}
+        for k, v in en_obj.items():
+            if k not in zh_obj:
+                added += 1
+                if isinstance(v, str):
+                    zh_obj[k] = f"<<TODO_TRANSLATE>> {v}"
+                else:
+                    # For non-string nodes, insert scaffold recursively
+                    zh_obj[k], inc = _merge_missing(
+                        v, {} if isinstance(v, dict) else [] if isinstance(v, list) else None
+                    )
+                    added += inc
+            else:
+                zh_obj[k], inc = _merge_missing(v, zh_obj[k])
+                added += inc
+        return zh_obj, added
+
+    if isinstance(en_obj, list):
+        # Do not attempt to merge list structures; keep existing zh list.
+        return zh_obj, 0
+
+    # Primitive leaf: nothing to do
+    return zh_obj, 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--write", action="store_true", help="write changes to disk")
+    parser.add_argument(
+        "--create-missing-files",
+        action="store_true",
+        help="create missing zh/cn files from en structure with TODO markers",
+    )
+    parser.add_argument(
+        "--target",
+        choices=["zh", "cn", "both"],
+        default="both",
+        help="which target language directory to sync",
+    )
+    args = parser.parse_args()
+
+    if not AGENTS_DIR.exists():
+        print(f"Agents directory not found: {AGENTS_DIR}", file=sys.stderr)
+        return 2
+
+    total_added = 0
+    total_files = 0
+
+    for module_dir in sorted([p for p in AGENTS_DIR.iterdir() if p.is_dir()]):
+        prompts_dir = module_dir / "prompts"
+        en_dir = prompts_dir / "en"
+        if not en_dir.exists():
+            continue
+
+        targets: list[tuple[str, Path]] = []
+        if args.target in ("zh", "both"):
+            targets.append(("zh", prompts_dir / "zh"))
+        if args.target in ("cn", "both"):
+            targets.append(("cn", prompts_dir / "cn"))
+
+        en_files = [p for p in en_dir.rglob("*.yaml") if p.is_file()]
+        for en_file in sorted(en_files):
+            rel = en_file.relative_to(en_dir)
+            en_obj = _load_yaml(en_file)
+            for lang_name, lang_dir in targets:
+                zh_file = lang_dir / rel
+                if not zh_file.exists():
+                    if not args.create_missing_files:
+                        print(f"[MISSING {lang_name}] {module_dir.name}: {rel.as_posix()}")
+                        continue
+                    zh_obj = {}
+                else:
+                    zh_obj = _load_yaml(zh_file)
+
+                new_obj, added = _merge_missing(en_obj, zh_obj)
+                if added == 0:
+                    continue
+
+                total_added += added
+                total_files += 1
+                print(f"[SYNC {lang_name}] {module_dir.name}: {rel.as_posix()} (+{added} keys)")
+
+                if args.write:
+                    _dump_yaml(zh_file, new_obj)
+
+    if total_files == 0:
+        print("No changes needed.")
+        return 0
+
+    if args.write:
+        print(f"Updated {total_files} file(s), added {total_added} key(s).")
+    else:
+        print(
+            f"Dry-run: would update {total_files} file(s), add {total_added} key(s). Use --write to apply."
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/cli/start.py

@@ -15,15 +15,15 @@ Usage:
 
 import argparse
 import os
+from pathlib import Path
 import subprocess
 import sys
-from pathlib import Path
 
 
 def create_parser() -> argparse.ArgumentParser:
     """
     Create CLI argument parser following Unix conventions.
-    
+
     Design: Minimal CLI options, environment-driven configuration.
     """
     parser = argparse.ArgumentParser(
@@ -46,79 +46,71 @@ Environment Variables:
 For more information: https://github.com/therealtimex/DeepTutor-local-app
         """,
     )
-    
+
     # Mode selection (future extensibility)
     mode_group = parser.add_mutually_exclusive_group()
     mode_group.add_argument(
         "--backend-only",
         action="store_true",
-        help="Start backend only (FastAPI) [NOT YET IMPLEMENTED]"
+        help="Start backend only (FastAPI) [NOT YET IMPLEMENTED]",
     )
     mode_group.add_argument(
         "--frontend-only",
         action="store_true",
-        help="Start frontend only (Next.js) [NOT YET IMPLEMENTED]"
+        help="Start frontend only (Next.js) [NOT YET IMPLEMENTED]",
     )
-    
+
     # Logging configuration
     parser.add_argument(
         "--log-level",
         choices=["DEBUG", "INFO", "WARNING", "ERROR"],
         default=os.getenv("LOG_LEVEL", "INFO"),
-        help="Logging level (default: INFO)"
+        help="Logging level (default: INFO)",
     )
-    
+
     return parser
 
 
 def find_project_root() -> Path:
     """
     Find DeepTutor project root directory.
-    
+
     Strategy:
-    1. Try installed package location
-    2. Fall back to development mode (current directory traversal)
-    3. Validate by checking for pyproject.toml
-    
+    1. Use __file__ location (works for both installed and development)
+    2. Fall back to pyproject.toml search for development mode
+
     Returns:
         Path: Absolute path to project root
-    
+
     Raises:
         RuntimeError: If project root cannot be determined
     """
-    # Try installed package
-    try:
-        import realtimex_deeptutor
-        root = Path(realtimex_deeptutor.__file__).parent.parent
-        if (root / "pyproject.toml").exists():
-            return root
-    except ImportError:
-        pass
-    
-    # Development mode: traverse up from this file
-    current = Path(__file__).resolve()
-    for parent in [current.parent, *current.parents]:
+    # Primary strategy: Use __file__ location
+    # This file is at: <root>/src/cli/start.py
+    # So root is 3 levels up: start.py -> cli -> src -> root
+    package_root = Path(__file__).resolve().parent.parent.parent
+
+    # Validate by checking for essential package content (not pyproject.toml)
+    if (package_root / "src" / "api").is_dir():
+        return package_root
+
+    # Fallback: Development mode - look for pyproject.toml
+    for parent in Path(__file__).resolve().parents:
         if (parent / "pyproject.toml").exists():
             return parent
-    
-    # Last resort: current working directory
-    cwd = Path.cwd()
-    if (cwd / "pyproject.toml").exists():
-        return cwd
-    
-    raise RuntimeError(
-        "Cannot find DeepTutor project root. "
-        "Make sure you are running from the project directory or have installed the package."
-    )
+
+    # Last fallback: return computed root without strict validation
+    # This allows the package to attempt startup even if structure is unusual
+    return package_root
 
 
 def validate_environment(project_root: Path) -> None:
     """
     Validate environment and dependencies.
-    
+
     Args:
         project_root: Path to project root
-    
+
     Raises:
         RuntimeError: If validation fails
     """
@@ -130,20 +122,24 @@ def validate_environment(project_root: Path) -> None:
             f"Project root: {project_root}\n"
             "Please ensure DeepTutor is properly installed."
         )
-    
-    # Check for web directory (frontend)
-    web_dir = project_root / "web"
-    if not web_dir.exists():
-        raise RuntimeError(
-            f"Frontend directory not found: {web_dir}\n"
-            "Please ensure the complete DeepTutor package is installed."
-        )
+
+    # Check for web directory only in development mode
+    # In production mode, frontend is served via npx @realtimex/opentutor-web
+    dev_mode = os.environ.get("FRONTEND_DEV_MODE", "").lower() in ("true", "1", "yes")
+    if dev_mode:
+        web_dir = project_root / "web"
+        if not web_dir.exists():
+            raise RuntimeError(
+                f"Frontend directory not found: {web_dir}\n"
+                "FRONTEND_DEV_MODE is enabled but web/ directory is missing.\n"
+                "Either disable dev mode or run from the project source directory."
+            )
 
 
 def main():
     """
     Main CLI entry point.
-    
+
     Flow:
     1. Parse arguments
     2. Find and validate project root
@@ -152,63 +148,59 @@ def main():
     """
     parser = create_parser()
     args = parser.parse_args()
-    
+
     try:
         # Find project root
         project_root = find_project_root()
-        
+
         # Validate environment
         validate_environment(project_root)
-        
+
         # Build environment for subprocess
         # All configuration comes from environment variables
         env = os.environ.copy()
-        
+
         # Set log level
         env["LOG_LEVEL"] = args.log_level
-        
+
         # Handle mode selection
         if args.backend_only:
             print("⚠️  Backend-only mode not yet implemented")
             print("   Use 'uvx realtimex-deeptutor' for full-stack startup")
             print("   Or use 'deeptutor-backend' for backend-only")
             sys.exit(1)
-        
+
         if args.frontend_only:
             print("⚠️  Frontend-only mode not yet implemented")
             print("   Use 'uvx realtimex-deeptutor' for full-stack startup")
             print("   Or use 'npx @realtimex/opentutor-web' for frontend-only")
             sys.exit(1)
-        
+
         # Full-stack mode: delegate to start_web.py
         print("🚀 Starting DeepTutor (Full Stack)...")
         print(f"📁 Project root: {project_root}")
-        
+
         script_path = project_root / "scripts" / "start_web.py"
-        
+
         # Launch start_web.py with updated environment
-        subprocess.run(
-            [sys.executable, str(script_path)],
-            env=env,
-            cwd=project_root,
-            check=True
-        )
-    
+        subprocess.run([sys.executable, str(script_path)], env=env, cwd=project_root, check=True)
+
     except KeyboardInterrupt:
         print("\n🛑 Shutting down...")
         sys.exit(0)
-    
+
     except RuntimeError as e:
         print(f"❌ Error: {e}", file=sys.stderr)
         sys.exit(1)
-    
+
     except subprocess.CalledProcessError as e:
         # start_web.py already printed error messages
         sys.exit(e.returncode)
-    
+
     except Exception as e:
         print(f"❌ Unexpected error: {e}", file=sys.stderr)
         import traceback
+
         traceback.print_exc()
         sys.exit(1)
 

src/services/config/unified_config.py

@@ -478,7 +478,7 @@ class UnifiedConfigManager:
 
             # Get user's active selection (or use defaults)
             active = get_rtx_active_config(config_type.value)
-            
+
             if active:
                 provider = active.get("provider", "realtimexai")
                 model = active.get("model", "")
@@ -596,7 +596,7 @@ class UnifiedConfigManager:
 
                 if should_use_realtimex_sdk():
                     rtx_active = get_rtx_active_config(config_type.value)
-                    
+
                     if rtx_active:
                         return {
                             "id": "rtx",