wydcode 0.4.3

package/socra_harness/events.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+
+def now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+class EventLog:
+    def __init__(self, path: Path | None):
+        self.path = path
+        if self.path:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def emit(self, event: str, **payload: Any) -> None:
+        if not self.path:
+            return
+        row = {"ts_ms": now_ms(), "event": event, **payload}
+        with self.path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(row, sort_keys=True) + "\n")
+
+
+def read_events(path: Path, limit: int = 200) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    if limit <= 0:
+        return []
+    lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+    out = []
+    for line in lines[-limit:]:
+        try:
+            out.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+    return out

package/socra_harness/init.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_ENDPOINT = "http://127.0.0.1:11439/v1"
+DEFAULT_CONTEXT_BUDGET = 8192
+DEFAULT_MAX_OUTPUT = 8192
+
+
+def run_git(project: Path, args: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        cwd=project,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        check=False,
+    )
+
+
+def require_git_repo(project: Path) -> Path:
+    result = run_git(project, ["rev-parse", "--show-toplevel"])
+    if result.returncode != 0:
+        raise SystemExit("wydcode init requires a git repository. Run git init first.")
+    return Path(result.stdout.strip()).resolve()
+
+
+def git_dirty(project: Path) -> bool:
+    result = run_git(project, ["status", "--porcelain"])
+    if result.returncode != 0:
+        return True
+    return bool(result.stdout.strip())
+
+
+def detect_package_manager(project: Path) -> str | None:
+    if (project / "pnpm-lock.yaml").exists():
+        return "pnpm"
+    if (project / "yarn.lock").exists():
+        return "yarn"
+    if (project / "bun.lockb").exists() or (project / "bun.lock").exists():
+        return "bun"
+    if (project / "package-lock.json").exists():
+        return "npm"
+    if (project / "package.json").exists():
+        return "npm"
+    return None
+
+
+def load_package_json(project: Path) -> dict[str, Any]:
+    path = project / "package.json"
+    if not path.exists():
+        return {}
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"package.json is not valid JSON: {exc}") from exc
+    if not isinstance(value, dict):
+        raise SystemExit("package.json must contain a JSON object.")
+    return value
+
+
+def package_command(package_manager: str, script: str) -> list[str]:
+    if package_manager == "npm":
+        return ["npm", "run", script]
+    if package_manager == "pnpm":
+        return ["pnpm", script]
+    if package_manager == "yarn":
+        return ["yarn", script]
+    if package_manager == "bun":
+        return ["bun", "run", script]
+    return [package_manager, "run", script]
+
+
+def detect_test_command(project: Path, package_manager: str | None) -> list[str] | None:
+    package = load_package_json(project)
+    scripts = package.get("scripts") if isinstance(package.get("scripts"), dict) else {}
+    if package_manager and isinstance(scripts, dict):
+        # Prefer explicitly finite CI/run scripts over watch-oriented defaults.
+        for script in ["test:run", "test:ci", "ci:test", "test", "check", "build"]:
+            value = scripts.get(script)
+            if isinstance(value, str) and value.strip():
+                return package_command(package_manager, script)
+    return None
+
+
+def detect_project_type(project: Path) -> str:
+    if (project / "package.json").exists():
+        package = load_package_json(project)
+        deps = {}
+        for key in ["dependencies", "devDependencies"]:
+            if isinstance(package.get(key), dict):
+                deps.update(package[key])
+        if "next" in deps:
+            return "node-nextjs"
+        if "react" in deps or "vite" in deps:
+            return "node-frontend"
+        return "node"
+    return "unknown"
+
+
+def probe_endpoint(endpoint: str, timeout: float = 1.0) -> dict[str, Any]:
+    base = endpoint.rstrip("/")
+    candidates = [base.removesuffix("/v1") + "/health", base + "/models"]
+    errors: list[str] = []
+    for url in candidates:
+        try:
+            with urllib.request.urlopen(url, timeout=timeout) as response:
+                body = response.read(4096).decode("utf-8", errors="replace")
+            parsed: Any
+            try:
+                parsed = json.loads(body) if body else {}
+            except json.JSONDecodeError:
+                parsed = {"raw": body[:256]}
+            return {"ok": True, "url": url, "status": "reachable", "response": parsed}
+        except (OSError, urllib.error.URLError, TimeoutError) as exc:
+            errors.append(f"{url}: {exc}")
+    return {"ok": False, "status": "unreachable", "errors": errors}
+
+
+def build_config(args: argparse.Namespace, project: Path, repo_root: Path) -> dict[str, Any]:
+    package_manager = detect_package_manager(repo_root)
+    test_command = detect_test_command(repo_root, package_manager)
+    endpoint = args.endpoint or os.environ.get("SOCRA_ENDPOINT") or DEFAULT_ENDPOINT
+    model = args.model or os.environ.get("SOCRA_MODEL")
+    endpoint_probe = probe_endpoint(endpoint) if not args.skip_endpoint_probe else {"ok": None, "status": "skipped"}
+    return {
+        "schema_version": 1,
+        "tool": "socra-harness",
+        "project_root": str(repo_root),
+        "initialized_from": str(project),
+        "git": {
+            "required": True,
+            "root": str(repo_root),
+            "dirty_at_init": git_dirty(repo_root),
+        },
+        "project": {
+            "type": detect_project_type(repo_root),
+            "package_manager": package_manager,
+            "test_command": test_command,
+        },
+        "model": {
+            "endpoint": endpoint,
+            "model": model,
+            "local_first": True,
+            "hosted_fallback": False,
+            "endpoint_probe": endpoint_probe,
+        },
+        "budgets": {
+            "context_budget_tokens": args.context_budget,
+            "max_output_tokens": args.max_output,
+        },
+        "output_contract": {
+            "record_finish_reason": True,
+            "record_content_chars": True,
+            "record_reasoning_chars": True,
+            "classify_length_without_content_separately": True,
+            "prefer_module_sized_tasks": True,
+        },
+        "promotion": {
+            "source_writes_require_promote": True,
+            "review_and_approval_are_separate_steps": True,
+            "approval_is_hash_bound": True,
+        },
+        "traces": {
+            "cross_project": True,
+            "home": "~/.wydcode/traces",
+            "source_of_truth": "hash_chained_jsonl",
+            "mumpix_index": True,
+        },
+    }
+
+
+def init_main(args: argparse.Namespace) -> int:
+    project = args.project.expanduser().resolve()
+    if not project.exists():
+        raise SystemExit(f"Project path does not exist: {project}")
+    if not project.is_dir():
+        raise SystemExit(f"Project path is not a directory: {project}")
+
+    repo_root = require_git_repo(project)
+    config = build_config(args, project, repo_root)
+    socra_dir = repo_root / ".socra"
+    socra_dir.mkdir(parents=True, exist_ok=True)
+    config_path = socra_dir / "config.json"
+    if config_path.exists() and not args.force:
+        raise SystemExit(f"{config_path} already exists. Pass --force to overwrite.")
+    config_path.write_text(json.dumps(config, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    print(f"Initialized Socra config: {config_path}")
+    print(f"Project: {repo_root}")
+    if config["git"]["dirty_at_init"]:
+        print("Warning: git worktree is dirty at init.")
+    package_manager = config["project"]["package_manager"] or "not detected"
+    print(f"Package manager: {package_manager}")
+    print(f"Test command: {' '.join(config['project']['test_command']) if config['project']['test_command'] else 'not detected'}")
+    probe = config["model"]["endpoint_probe"]
+    print(f"Endpoint: {config['model']['endpoint']} ({probe.get('status')})")
+    return 0

package/socra_harness/job/__init__.py

@@ -0,0 +1,2 @@
+"""Durable long-running Socra job primitives."""
+

package/socra_harness/job/events.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import dataclasses
+import datetime as dt
+import hashlib
+import json
+import os
+import warnings
+from pathlib import Path
+from typing import Any
+
+
+EVENT_SCHEMA_VERSION = 1
+IDEMPOTENT_DUPLICATE_EVENT_TYPES = {
+    "creator_endpoint_health_checked",
+}
+
+
+class JobEventError(RuntimeError):
+    pass
+
+
+@dataclasses.dataclass(frozen=True)
+class JobEvent:
+    schema_version: int
+    seq: int
+    event_id: str
+    timestamp: str
+    job_id: str
+    type: str
+    payload: dict[str, Any]
+
+    def to_json(self) -> dict[str, Any]:
+        return dataclasses.asdict(self)
+
+
+def now_iso() -> str:
+    return dt.datetime.now(dt.timezone.utc).isoformat()
+
+
+def event_id(seq: int) -> str:
+    return f"evt-{seq:06d}"
+
+
+def validate_event(data: dict[str, Any]) -> JobEvent:
+    required = {"schema_version", "seq", "event_id", "timestamp", "job_id", "type", "payload"}
+    missing = required - set(data)
+    if missing:
+        raise JobEventError(f"event missing required fields: {sorted(missing)}")
+    if data["schema_version"] != EVENT_SCHEMA_VERSION:
+        raise JobEventError(f"schema_migration_required: {data['schema_version']}")
+    if not isinstance(data["seq"], int) or data["seq"] < 1:
+        raise JobEventError("event seq must be a positive integer")
+    if data["event_id"] != event_id(data["seq"]):
+        raise JobEventError(f"event_id does not match seq: {data['event_id']} vs {event_id(data['seq'])}")
+    if not isinstance(data["payload"], dict):
+        raise JobEventError("event payload must be an object")
+    return JobEvent(
+        schema_version=data["schema_version"],
+        seq=data["seq"],
+        event_id=data["event_id"],
+        timestamp=str(data["timestamp"]),
+        job_id=str(data["job_id"]),
+        type=str(data["type"]),
+        payload=data["payload"],
+    )
+
+
+def read_events(path: Path) -> list[JobEvent]:
+    if not path.exists():
+        return []
+    events: list[JobEvent] = []
+    previous_seq = 0
+    previous_fingerprint: str | None = None
+    text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    final_line_may_be_torn = bool(lines) and not text.endswith("\n")
+    for line_no, line in enumerate(lines, start=1):
+        if not line.strip():
+            continue
+        try:
+            raw = json.loads(line)
+        except json.JSONDecodeError as exc:
+            if final_line_may_be_torn and line_no == len(lines):
+                warnings.warn(f"dropping torn final event line in {path}: {exc}", RuntimeWarning)
+                break
+            raise JobEventError(f"invalid JSON at line {line_no}: {exc}") from exc
+        event = validate_event(raw)
+        if event.seq != previous_seq + 1:
+            raise JobEventError(f"non-monotonic event seq at line {line_no}: {event.seq} after {previous_seq}")
+        fingerprint_payload = {
+            "job_id": event.job_id,
+            "type": event.type,
+            "payload": event.payload,
+        }
+        fingerprint = hashlib.sha256(json.dumps(fingerprint_payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("utf-8")).hexdigest()
+        if previous_fingerprint == fingerprint and event.type not in IDEMPOTENT_DUPLICATE_EVENT_TYPES:
+            warnings.warn(
+                f"adjacent duplicate event content fingerprint in {path}: line {line_no}",
+                RuntimeWarning,
+            )
+        previous_fingerprint = fingerprint
+        previous_seq = event.seq
+        events.append(event)
+    return events
+
+
+class JobEventLog:
+    def __init__(self, path: Path, job_id: str):
+        self.path = path
+        self.job_id = job_id
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def next_seq(self) -> int:
+        return len(read_events(self.path)) + 1
+
+    def append(self, event_type: str, payload: dict[str, Any] | None = None) -> JobEvent:
+        seq = self.next_seq()
+        event = JobEvent(
+            schema_version=EVENT_SCHEMA_VERSION,
+            seq=seq,
+            event_id=event_id(seq),
+            timestamp=now_iso(),
+            job_id=self.job_id,
+            type=event_type,
+            payload=payload or {},
+        )
+        with self.path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(event.to_json(), ensure_ascii=False) + "\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        return event

package/socra_harness/job/lock.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+
+class JobLockError(RuntimeError):
+    pass
+
+
+@dataclasses.dataclass
+class JobLock:
+    path: Path
+    stale_after_seconds: int = 24 * 60 * 60
+
+    def __enter__(self) -> JobLock:
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        self.release()
+
+    def acquire(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        while True:
+            try:
+                fd = os.open(str(self.path), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+            except FileExistsError:
+                if self._remove_if_stale():
+                    continue
+                raise JobLockError(f"job is already locked: {self.path}") from None
+            payload = {
+                "pid": os.getpid(),
+                "created_at": time.time(),
+            }
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                handle.write(json.dumps(payload, indent=2) + "\n")
+                handle.flush()
+                os.fsync(handle.fileno())
+            return
+
+    def release(self) -> None:
+        try:
+            payload = self._read_payload()
+            if int(payload.get("pid", -1)) == os.getpid():
+                self.path.unlink()
+        except FileNotFoundError:
+            return
+        except (OSError, ValueError):
+            return
+
+    def _read_payload(self) -> dict[str, Any]:
+        return json.loads(self.path.read_text(encoding="utf-8"))
+
+    def _remove_if_stale(self) -> bool:
+        try:
+            payload = self._read_payload()
+            pid = int(payload.get("pid", -1))
+            created_at = float(payload.get("created_at", 0))
+        except (OSError, ValueError, json.JSONDecodeError):
+            pid = -1
+            created_at = 0
+
+        if pid > 0 and self._pid_is_alive(pid):
+            return False
+
+        if created_at and time.time() - created_at < self.stale_after_seconds and pid > 0:
+            return False
+
+        try:
+            self.path.unlink()
+            return True
+        except FileNotFoundError:
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def _pid_is_alive(pid: int) -> bool:
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True
+        return True