refactor to reorganise codebase

Author: RayBytes

build.py

@@ -158,7 +158,7 @@ def make_dmg(app_path: Path, dmg_path: Path, volume_name: str) -> None:
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--name", default="ChatMock")
-    parser.add_argument("--entry", default="app_qt.py")
+    parser.add_argument("--entry", default="gui.py")
     parser.add_argument("--icon", default="icon.png")
     parser.add_argument("--radius", type=float, default=0.22)
     parser.add_argument("--square", action="store_true")

chatmock.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .app import create_app
+from .cli import main
+

chatmock/__init__.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from flask import Flask, jsonify
+
+from .config import BASE_INSTRUCTIONS
+from .http import build_cors_headers
+from .routes_openai import openai_bp
+from .routes_ollama import ollama_bp
+
+
+def create_app(
+    verbose: bool = False,
+    reasoning_effort: str = "medium",
+    reasoning_summary: str = "auto",
+    reasoning_compat: str = "think-tags",
+    debug_model: str | None = None,
+) -> Flask:
+    app = Flask(__name__)
+
+    app.config.update(
+        VERBOSE=bool(verbose),
+        REASONING_EFFORT=reasoning_effort,
+        REASONING_SUMMARY=reasoning_summary,
+        REASONING_COMPAT=reasoning_compat,
+        DEBUG_MODEL=debug_model,
+        BASE_INSTRUCTIONS=BASE_INSTRUCTIONS,
+    )
+
+    @app.get("/")
+    @app.get("/health")
+    def health():
+        return jsonify({"status": "ok"})
+
+    @app.after_request
+    def _cors(resp):
+        for k, v in build_cors_headers().items():
+            resp.headers.setdefault(k, v)
+        return resp
+
+    app.register_blueprint(openai_bp)
+    app.register_blueprint(ollama_bp)
+
+    return app
+

chatmock/app.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import argparse
+import json
+import errno
+import os
+import sys
+import webbrowser
+
+from .app import create_app
+from .config import CLIENT_ID_DEFAULT
+from .oauth import OAuthHTTPServer, OAuthHandler, REQUIRED_PORT, URL_BASE
+from .utils import eprint, get_home_dir, load_chatgpt_tokens, parse_jwt_claims, read_auth_file
+
+
+def cmd_login(no_browser: bool, verbose: bool) -> int:
+    home_dir = get_home_dir()
+    client_id = CLIENT_ID_DEFAULT
+    if not client_id:
+        eprint("ERROR: No OAuth client id configured. Set CHATGPT_LOCAL_CLIENT_ID.")
+        return 1
+
+    try:
+        httpd = OAuthHTTPServer(("127.0.0.1", REQUIRED_PORT), OAuthHandler, home_dir=home_dir, client_id=client_id, verbose=verbose)
+    except OSError as e:
+        eprint(f"ERROR: {e}")
+        if e.errno == errno.EADDRINUSE:
+            return 13
+        return 1
+
+    auth_url = httpd.auth_url()
+    with httpd:
+        eprint(f"Starting local login server on {URL_BASE}")
+        if not no_browser:
+            try:
+                webbrowser.open(auth_url, new=1, autoraise=True)
+            except Exception as e:
+                eprint(f"Failed to open browser: {e}")
+        eprint(f"If your browser did not open, navigate to:\n{auth_url}")
+        try:
+            httpd.serve_forever()
+        except KeyboardInterrupt:
+            eprint("\nKeyboard interrupt received, exiting.")
+        return httpd.exit_code
+
+
+def cmd_serve(
+    host: str,
+    port: int,
+    verbose: bool,
+    reasoning_effort: str,
+    reasoning_summary: str,
+    reasoning_compat: str,
+    debug_model: str | None,
+) -> int:
+    app = create_app(
+        verbose=verbose,
+        reasoning_effort=reasoning_effort,
+        reasoning_summary=reasoning_summary,
+        reasoning_compat=reasoning_compat,
+        debug_model=debug_model,
+    )
+
+    app.run(host=host, debug=False, use_reloader=False, port=port, threaded=True)
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="ChatGPT Local: login & OpenAI-compatible proxy")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_login = sub.add_parser("login", help="Authorize with ChatGPT and store tokens")
+    p_login.add_argument("--no-browser", action="store_true", help="Do not open the browser automatically")
+    p_login.add_argument("--verbose", action="store_true", help="Enable verbose logging")
+
+    p_serve = sub.add_parser("serve", help="Run local OpenAI-compatible server")
+    p_serve.add_argument("--host", default="127.0.0.1")
+    p_serve.add_argument("--port", type=int, default=8000)
+    p_serve.add_argument("--verbose", action="store_true", help="Enable verbose logging")
+    p_serve.add_argument(
+        "--debug-model",
+        dest="debug_model",
+        default=os.getenv("CHATGPT_LOCAL_DEBUG_MODEL"),
+        help="Forcibly override requested 'model' with this value",
+    )
+    p_serve.add_argument(
+        "--reasoning-effort",
+        choices=["low", "medium", "high", "none"],
+        default=os.getenv("CHATGPT_LOCAL_REASONING_EFFORT", "medium").lower(),
+        help="Reasoning effort level for Responses API (default: medium)",
+    )
+    p_serve.add_argument(
+        "--reasoning-summary",
+        choices=["auto", "concise", "detailed", "none"],
+        default=os.getenv("CHATGPT_LOCAL_REASONING_SUMMARY", "auto").lower(),
+        help="Reasoning summary verbosity (default: auto)",
+    )
+    p_serve.add_argument(
+        "--reasoning-compat",
+        choices=["legacy", "o3", "think-tags", "current"],
+        default=os.getenv("CHATGPT_LOCAL_REASONING_COMPAT", "think-tags").lower(),
+        help=(
+            "Compatibility mode for exposing reasoning to clients (legacy|o3|think-tags). "
+            "'current' is accepted as an alias for 'legacy'"
+        ),
+    )
+
+    p_info = sub.add_parser("info", help="Print current stored tokens and derived account id")
+    p_info.add_argument("--json", action="store_true", help="Output raw auth.json contents")
+
+    args = parser.parse_args()
+
+    if args.command == "login":
+        sys.exit(cmd_login(no_browser=args.no_browser, verbose=args.verbose))
+    elif args.command == "serve":
+        sys.exit(
+            cmd_serve(
+                host=args.host,
+                port=args.port,
+                verbose=args.verbose,
+                reasoning_effort=args.reasoning_effort,
+                reasoning_summary=args.reasoning_summary,
+                reasoning_compat=args.reasoning_compat,
+                debug_model=args.debug_model,
+            )
+        )
+    elif args.command == "info":
+        auth = read_auth_file()
+        if getattr(args, "json", False):
+            print(json.dumps(auth or {}, indent=2))
+            sys.exit(0)
+        access_token, account_id, id_token = load_chatgpt_tokens()
+        if not access_token or not id_token:
+            print("👤 Account")
+            print("  • Not signed in")
+            print("  • Run: python3 chatmock.py login")
+            sys.exit(0)
+
+        id_claims = parse_jwt_claims(id_token) or {}
+        access_claims = parse_jwt_claims(access_token) or {}
+
+        email = id_claims.get("email") or id_claims.get("preferred_username") or "<unknown>"
+        plan_raw = (access_claims.get("https://api.openai.com/auth") or {}).get("chatgpt_plan_type") or "unknown"
+        plan_map = {
+            "plus": "Plus",
+            "pro": "Pro",
+            "free": "Free",
+            "team": "Team",
+            "enterprise": "Enterprise",
+        }
+        plan = plan_map.get(str(plan_raw).lower(), str(plan_raw).title() if isinstance(plan_raw, str) else "Unknown")
+
+        print("👤 Account")
+        print("  • Signed in with ChatGPT")
+        print(f"  • Login: {email}")
+        print(f"  • Plan: {plan}")
+        if account_id:
+            print(f"  • Account ID: {account_id}")
+        sys.exit(0)
+    else:
+        parser.error("Unknown command")
+
+
+if __name__ == "__main__":
+    main()

chatmock/cli.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+CLIENT_ID_DEFAULT = os.getenv("CHATGPT_LOCAL_CLIENT_ID") or "app_EMoamEEZ73f0CkXaXp7hrann"
+
+CHATGPT_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses"
+
+
+def read_base_instructions() -> str:
+    candidates = [
+        Path(__file__).parent.parent / "prompt.md",
+        Path(__file__).parent / "prompt.md",
+        Path(getattr(sys, "_MEIPASS", "")) / "prompt.md" if getattr(sys, "_MEIPASS", None) else None,
+        Path.cwd() / "prompt.md",
+    ]
+    for p in candidates:
+        if not p:
+            continue
+        try:
+            if p.exists():
+                content = p.read_text(encoding="utf-8")
+                if isinstance(content, str) and content.strip():
+                    return content
+        except Exception:
+            continue
+    raise FileNotFoundError(
+        "Failed to read prompt.md; expected adjacent to package or CWD."
+    )
+
+
+BASE_INSTRUCTIONS = read_base_instructions()

chatmock/config.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from flask import Response, jsonify, request
+
+
+def build_cors_headers() -> dict:
+    origin = request.headers.get("Origin", "*")
+    req_headers = request.headers.get("Access-Control-Request-Headers")
+    allow_headers = req_headers if req_headers else "Authorization, Content-Type, Accept"
+    return {
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+        "Access-Control-Allow-Headers": allow_headers,
+        "Access-Control-Max-Age": "86400",
+    }
+
+
+def json_error(message: str, status: int = 400) -> Response:
+    resp = jsonify({"error": {"message": message}})
+    response: Response = Response(response=resp.response, status=status, mimetype="application/json")
+    for k, v in build_cors_headers().items():
+        response.headers.setdefault(k, v)
+    return response
+

chatmock/http.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Optional
 

models.py chatmock/models.pymodels.py renamed to chatmock/models.py

@@ -10,8 +10,8 @@
 import urllib.request
 from typing import Any, Dict, Tuple
 
-from models import AuthBundle, PkceCodes, TokenData
-from utils import eprint, generate_pkce, parse_jwt_claims, write_auth_file
+from .models import AuthBundle, PkceCodes, TokenData
+from .utils import eprint, generate_pkce, parse_jwt_claims, write_auth_file
 
 
 REQUIRED_PORT = 1455
@@ -31,7 +31,7 @@
       <p>You can now close this window and return to the terminal and run <code>python3 chatmock.py serve</code> to start the server.</p>
     </div>
   </body>
-</html>
+  </html>
 """
 
 
@@ -258,3 +258,4 @@ def _maybe_obtain_api_key(
         }
         success_url = f"{URL_BASE}/success?{urllib.parse.urlencode(success_url_query)}"
         return exchanged_access_token, success_url
+

oauth.py chatmock/oauth.pyoauth.py renamed to chatmock/oauth.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+
+def build_reasoning_param(
+    base_effort: str = "medium", base_summary: str = "auto", overrides: Dict[str, Any] | None = None
+) -> Dict[str, Any]:
+    effort = (base_effort or "").strip().lower()
+    summary = (base_summary or "").strip().lower()
+
+    valid_efforts = {"low", "medium", "high", "none"}
+    valid_summaries = {"auto", "concise", "detailed", "none"}
+
+    if isinstance(overrides, dict):
+        o_eff = str(overrides.get("effort", "")).strip().lower()
+        o_sum = str(overrides.get("summary", "")).strip().lower()
+        if o_eff in valid_efforts and o_eff:
+            effort = o_eff
+        if o_sum in valid_summaries and o_sum:
+            summary = o_sum
+    if effort not in valid_efforts:
+        effort = "medium"
+    if summary not in valid_summaries:
+        summary = "auto"
+
+    reasoning: Dict[str, Any] = {"effort": effort}
+    if summary != "none":
+        reasoning["summary"] = summary
+    return reasoning
+
+
+def apply_reasoning_to_message(
+    message: Dict[str, Any],
+    reasoning_summary_text: str,
+    reasoning_full_text: str,
+    compat: str,
+) -> Dict[str, Any]:
+    try:
+        compat = (compat or "think-tags").strip().lower()
+    except Exception:
+        compat = "think-tags"
+
+    if compat == "o3":
+        rtxt_parts: list[str] = []
+        if isinstance(reasoning_summary_text, str) and reasoning_summary_text.strip():
+            rtxt_parts.append(reasoning_summary_text)
+        if isinstance(reasoning_full_text, str) and reasoning_full_text.strip():
+            rtxt_parts.append(reasoning_full_text)
+        rtxt = "\n\n".join([p for p in rtxt_parts if p])
+        if rtxt:
+            message["reasoning"] = {"content": [{"type": "text", "text": rtxt}]}
+        return message
+
+    if compat in ("legacy", "current"):
+        if reasoning_summary_text:
+            message["reasoning_summary"] = reasoning_summary_text
+        if reasoning_full_text:
+            message["reasoning"] = reasoning_full_text
+        return message
+
+    rtxt_parts: list[str] = []
+    if isinstance(reasoning_summary_text, str) and reasoning_summary_text.strip():
+        rtxt_parts.append(reasoning_summary_text)
+    if isinstance(reasoning_full_text, str) and reasoning_full_text.strip():
+        rtxt_parts.append(reasoning_full_text)
+    rtxt = "\n\n".join([p for p in rtxt_parts if p])
+    if rtxt:
+        think_block = f"<think>{rtxt}</think>"
+        content_text = message.get("content") or ""
+        if isinstance(content_text, str):
+            message["content"] = think_block + (content_text or "")
+    return message
+