wydcode 0.4.3

package/socra_harness/start.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from .scan.repo import scan_main
+from .serve.local_proxy import serve_main
+from .tui.app import tui_main
+
+
+COMMON_MODEL_DIRS = [
+    Path.home() / "Downloads",
+    Path.home() / "models",
+    Path.home() / "Desktop" / "dev" / "models",
+    Path.home() / "Desktop" / "dev" / "APM" / "dist",
+    Path.home() / "Desktop" / "dev" / "updates",
+]
+
+
+def socra_home() -> Path:
+    override = os.environ.get("SOCRA_HARNESS_HOME")
+    if override:
+        return Path(override).expanduser().resolve()
+    return Path.home() / ".socra-harness"
+
+
+def recent_projects_path() -> Path:
+    return socra_home() / "recent-projects.json"
+
+
+def discover_models(extra_dirs: list[Path]) -> list[Path]:
+    seen = set()
+    models = []
+    for root in [*extra_dirs, *COMMON_MODEL_DIRS]:
+        if not root.exists():
+            continue
+        for path in root.rglob("*.gguf"):
+            if path in seen:
+                continue
+            seen.add(path)
+            models.append(path)
+    return sorted(models, key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+
+
+def read_recent_projects() -> list[dict[str, Any]]:
+    path = recent_projects_path()
+    if not path.exists():
+        return []
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return []
+    projects = data.get("projects") if isinstance(data, dict) else data
+    if not isinstance(projects, list):
+        return []
+    clean = []
+    for item in projects:
+        if not isinstance(item, dict):
+            continue
+        raw_path = item.get("path")
+        if isinstance(raw_path, str) and raw_path:
+            clean.append(item)
+    return clean
+
+
+def write_recent_projects(projects: list[dict[str, Any]]) -> None:
+    path = recent_projects_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {"version": 1, "projects": projects[:30]}
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+def remember_project(project: Path, model: Path | None = None, alias: str | None = None) -> None:
+    project = project.expanduser().resolve()
+    now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    existing = read_recent_projects()
+    kept = [item for item in existing if Path(str(item.get("path"))).expanduser().resolve() != project]
+    entry = {
+        "name": project.name,
+        "path": str(project),
+        "state_dir": str(project / ".socra"),
+        "last_opened_at": now,
+    }
+    if model:
+        entry["last_model"] = str(model)
+    if alias:
+        entry["last_alias"] = alias
+    write_recent_projects([entry, *kept])
+
+
+def discover_socra_projects() -> list[Path]:
+    roots = [Path.home() / "Desktop", Path.home() / "Desktop" / "dev"]
+    found: list[Path] = []
+    seen: set[Path] = set()
+    skip = {".git", "node_modules", ".next", "dist", "build", "DerivedData", ".venv", "venv", "__pycache__"}
+    for root in roots:
+        if not root.exists():
+            continue
+        root_depth = len(root.resolve().parts)
+        for dirpath, dirnames, _filenames in os.walk(root):
+            current = Path(dirpath)
+            depth = len(current.resolve().parts) - root_depth
+            dirnames[:] = [name for name in dirnames if name not in skip and not name.endswith(".xcarchive")]
+            if ".socra" in dirnames:
+                project = current.resolve()
+                if project not in seen:
+                    seen.add(project)
+                    found.append(project)
+                    if len(found) >= 25:
+                        return found
+            if depth >= 4:
+                dirnames[:] = []
+    return found
+
+
+def prompt_choice(title: str, choices: list[str], allow_custom: bool = False, custom_label: str = "New / custom path", custom_prompt: str = "Path") -> str:
+    print(f"\n{title}")
+    for index, item in enumerate(choices, start=1):
+        print(f"  {index}. {item}")
+    if allow_custom:
+        print(f"  n. {custom_label}")
+    while True:
+        raw = input("> ").strip()
+        if allow_custom and raw.lower() in {"n", "new"}:
+            return input(f"{custom_prompt}: ").strip()
+        if raw.isdigit() and 1 <= int(raw) <= len(choices):
+            return choices[int(raw) - 1]
+        print("Choose a listed number" + (" or n" if allow_custom else "") + ".")
+
+
+def choose_model(args: Any) -> Path:
+    if args.model:
+        return args.model.expanduser().resolve()
+    models = discover_models([Path(p).expanduser() for p in args.model_dir])
+    if not models:
+        raw = input("No GGUF models found. Enter model path: ").strip()
+        return Path(raw).expanduser().resolve()
+    labels = []
+    for path in models[:25]:
+        size_gb = path.stat().st_size / (1024 ** 3)
+        labels.append(f"{path.name}  ({size_gb:.1f} GiB)  {path}")
+    selected = prompt_choice("Pick a GGUF model", labels, allow_custom=True, custom_label="Custom model path", custom_prompt="Model path")
+    if selected.startswith("/") or selected.startswith("~"):
+        return Path(selected).expanduser().resolve()
+    return models[labels.index(selected)].resolve()
+
+
+def desktop_project_path(raw: str) -> Path:
+    value = raw.strip()
+    if not value:
+        raise SystemExit("Project name cannot be empty.")
+    path = Path(value).expanduser()
+    if path.is_absolute() or value.startswith("~") or "/" in value:
+        return path.resolve()
+    safe_name = "".join(char if char.isalnum() or char in {" ", "-", "_", "."} else "-" for char in value).strip()
+    if not safe_name:
+        raise SystemExit("Project name must contain at least one usable character.")
+    return (Path.home() / "Desktop" / safe_name).resolve()
+
+
+def choose_project(args: Any) -> Path:
+    if args.project:
+        return args.project.expanduser().resolve()
+    recent_paths = []
+    for item in read_recent_projects():
+        path = Path(str(item.get("path"))).expanduser()
+        if path.exists():
+            recent_paths.append(path.resolve())
+    recent_roots = [
+        Path.home() / "Desktop" / "dev" / "P" / "Vane-master",
+        Path.home() / "Desktop" / "dev" / "AxiomIOSBrowser",
+        Path.home() / "Desktop" / "dev" / "socra-harness",
+        Path.cwd(),
+    ]
+    seen: set[Path] = set()
+    choices_paths: list[Path] = []
+    for path in [*recent_paths, *recent_roots, *discover_socra_projects()]:
+        resolved = path.expanduser().resolve()
+        if resolved in seen or not resolved.exists():
+            continue
+        seen.add(resolved)
+        choices_paths.append(resolved)
+    choices = [str(path) for path in choices_paths]
+    selected = prompt_choice(
+        "Pick a project folder",
+        choices,
+        allow_custom=True,
+        custom_label="New Desktop project or custom path",
+        custom_prompt="Project name or path",
+    )
+    project = desktop_project_path(selected)
+    created = not project.exists()
+    project.mkdir(parents=True, exist_ok=True)
+    if created:
+        (project / "README.md").write_text(f"# {project.name}\n\nCreated by Socra Harness.\n")
+        print(f"Created new project folder: {project}")
+    return project
+
+
+def start_main(args: Any) -> int:
+    model = choose_model(args)
+    project = choose_project(args)
+    state_dir = project / ".socra"
+    state_dir.mkdir(parents=True, exist_ok=True)
+
+    alias = args.alias or model.stem
+    remember_project(project, model=model, alias=alias)
+    config = {
+        "model": str(model),
+        "alias": alias,
+        "project": str(project),
+        "endpoint": f"http://127.0.0.1:{args.port}/v1",
+        "state_dir": str(state_dir),
+        "local_first": True,
+        "hosted_fallback": False,
+        "sandbox": {
+            "network": bool(args.allow_sandbox_network),
+            "installs": bool(args.allow_sandbox_installs),
+            "root": str(state_dir / "run-sandbox" / "command-workspace"),
+        },
+    }
+    (state_dir / "session.json").write_text(json.dumps(config, indent=2) + "\n")
+
+    if not args.no_scan:
+        scan_args = argparse.Namespace(
+            folder=project,
+            out=state_dir / "candidates.json",
+            event_log=state_dir / "events.jsonl",
+        )
+        scan_main(scan_args)
+
+    serve_args = argparse.Namespace(
+        model=model,
+        alias=alias,
+        llama_server=args.llama_server,
+        host="127.0.0.1",
+        port=args.port,
+        backend_host="127.0.0.1",
+        backend_port=args.backend_port,
+        ctx_size=args.ctx_size,
+        gpu_layers=args.gpu_layers,
+        reuse_backend=False,
+        event_log=state_dir / "events.jsonl",
+    )
+
+    print("\nSocra Harness session")
+    print(f"  Project: {project}")
+    print(f"  Model:   {alias} ({model})")
+    print(f"  UI:      socra-harness tui --state-dir {state_dir}")
+    print(f"  API:     http://127.0.0.1:{args.port}/v1")
+    print("\nPoint Codex/editor tools at the API URL to vibe code with model + Socra harness.\n")
+    if args.no_ui:
+        return serve_main(serve_args)
+    return start_runtime_with_tui(args, serve_args, state_dir)
+
+
+def endpoint_ready(port: int) -> bool:
+    try:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=2) as res:
+            return res.status == 200
+    except Exception:
+        return False
+
+
+def wait_for_endpoint(port: int, timeout_seconds: int = 180) -> bool:
+    deadline = time.time() + timeout_seconds
+    while time.time() < deadline:
+        if endpoint_ready(port):
+            return True
+        time.sleep(1)
+    return False
+
+
+def start_runtime_with_tui(args: Any, serve_args: argparse.Namespace, state_dir: Path) -> int:
+    out_log = state_dir / "socra-harness-serve.out.log"
+    err_log = state_dir / "socra-harness-serve.err.log"
+    cmd = [
+        sys.executable,
+        "-m",
+        "socra_harness.cli",
+        "serve",
+        "--model",
+        str(serve_args.model),
+        "--alias",
+        str(serve_args.alias),
+        "--llama-server",
+        str(serve_args.llama_server),
+        "--host",
+        serve_args.host,
+        "--port",
+        str(serve_args.port),
+        "--backend-host",
+        serve_args.backend_host,
+        "--backend-port",
+        str(serve_args.backend_port),
+        "--ctx-size",
+        str(serve_args.ctx_size),
+        "--gpu-layers",
+        str(serve_args.gpu_layers),
+        "--event-log",
+        str(serve_args.event_log),
+    ]
+    env = os.environ.copy()
+    package_root = str(Path(__file__).resolve().parents[1])
+    env["PYTHONPATH"] = package_root + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+    with out_log.open("a", encoding="utf-8") as out, err_log.open("a", encoding="utf-8") as err:
+        proc = subprocess.Popen(cmd, stdout=out, stderr=err, env=env)
+    print("Starting Socra Harness runtime in the background for this terminal session...")
+    print(f"  stdout: {out_log}")
+    print(f"  stderr: {err_log}")
+    if not wait_for_endpoint(serve_args.port):
+        proc.terminate()
+        raise SystemExit(f"Socra Harness endpoint did not become ready. Check {err_log}")
+    print("Runtime ready. Opening terminal dashboard. Press q to stop the session.")
+    try:
+        tui_args = argparse.Namespace(state_dir=state_dir, refresh=args.ui_refresh)
+        return tui_main(tui_args)
+    finally:
+        if proc.poll() is None:
+            proc.terminate()
+            try:
+                proc.wait(timeout=15)
+            except subprocess.TimeoutExpired:
+                proc.kill()

package/socra_harness/tui/__init__.py

@@ -0,0 +1 @@
+