wydcode 0.4.3

package/socra_harness/product.py

@@ -0,0 +1,533 @@
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import re
+import shlex
+from pathlib import Path
+from typing import Any
+
+from .attempts import detect_interrupted_attempt
+from .central_traces import project_identity, sync_job_traces
+from .init import probe_endpoint, require_git_repo
+from .job.events import JobEventLog, read_events
+from .job.lock import JobLock
+from .job.manager import (
+    find_latest_incomplete_job,
+    job_promote_main,
+    job_reject_promotion_main,
+    job_review_promotion_main,
+    job_root,
+    job_run_milestone_main,
+    job_run_next_main,
+    new_job_id,
+    write_handoff,
+    write_json,
+)
+from .job.planner import canonical_task_hash, materialize_plan_from_events, ready_task_ids, validate_task_graph
+from .job.state import replay, state_to_json, write_state_snapshot
+from .recurrence import load_behavior_preference, load_gene_evidence, load_recurrence_card, normalize_repository
+
+
+def config_path(repo_root: Path) -> Path:
+    return repo_root / ".socra" / "config.json"
+
+
+def load_config(repo_root: Path) -> dict[str, Any]:
+    path = config_path(repo_root)
+    if not path.exists():
+        raise SystemExit(f"Socra config not found: {path}. Run wydcode init first.")
+    try:
+        config = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"Socra config is invalid JSON: {exc}") from exc
+    if not isinstance(config, dict):
+        raise SystemExit("Socra config must contain a JSON object.")
+    if config.get("schema_version") != 1:
+        raise SystemExit(f"Unsupported Socra config schema_version: {config.get('schema_version')}")
+    return config
+
+
+def model_config(config: dict[str, Any]) -> dict[str, Any]:
+    model = config.get("model") if isinstance(config.get("model"), dict) else {}
+    if not model.get("endpoint"):
+        raise SystemExit("Socra config has no model.endpoint. Run wydcode init --endpoint ...")
+    return model
+
+
+def require_live_endpoint(config: dict[str, Any]) -> dict[str, Any]:
+    model = model_config(config)
+    probe = probe_endpoint(str(model["endpoint"]), timeout=2.0)
+    if not probe.get("ok"):
+        errors = probe.get("errors") if isinstance(probe.get("errors"), list) else []
+        detail = f" Details: {'; '.join(str(item) for item in errors[:2])}" if errors else ""
+        raise SystemExit(f"Configured model endpoint is not reachable: {model['endpoint']}.{detail}")
+    return probe
+
+
+SOURCE_SUFFIXES = {".js", ".jsx", ".ts", ".tsx"}
+TEST_NAME_MARKERS = (".test.", ".spec.")
+SOURCE_DIR_PARTS = {"src", "lib", "app", "pages", "components", "packages", "plugins", "plugin"}
+PATH_STOPWORDS = {
+    "the",
+    "and",
+    "for",
+    "with",
+    "from",
+    "into",
+    "inside",
+    "single",
+    "value",
+    "nested",
+    "partial",
+    "updates",
+    "update",
+    "should",
+    "without",
+    "instead",
+    "removes",
+    "other",
+    "file",
+    "files",
+    "bug",
+    "fix",
+    "test",
+    "tests",
+    "plugin",
+    "src",
+}
+
+
+def split_identifier(text: str) -> list[str]:
+    parts = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text).lower()
+    return [token for token in re.split(r"[^a-z0-9]+", parts) if token]
+
+
+def goal_tokens(goal: str) -> set[str]:
+    return {token for token in split_identifier(goal) if len(token) >= 3 and token not in PATH_STOPWORDS}
+
+
+def goal_terms(goal: str) -> set[str]:
+    terms = goal_tokens(goal)
+    for raw in re.findall(r"[A-Za-z][A-Za-z0-9]*", goal):
+        text = raw.lower()
+        if len(text) >= 3 and text not in PATH_STOPWORDS:
+            terms.add(text)
+    return terms
+
+
+def source_candidates(repo_root: Path) -> list[Path]:
+    candidates: list[Path] = []
+    for base in [repo_root / part for part in SOURCE_DIR_PARTS if (repo_root / part).is_dir()]:
+        for path in base.rglob("*"):
+            if not path.is_file() or path.suffix not in SOURCE_SUFFIXES:
+                continue
+            if any(marker in path.name for marker in TEST_NAME_MARKERS):
+                continue
+            rel_parts = set(path.relative_to(repo_root).parts)
+            if "node_modules" in rel_parts or ".socra" in rel_parts:
+                continue
+            candidates.append(path.relative_to(repo_root))
+    for name in ["index.js", "main.js", "index.ts", "main.ts"]:
+        path = repo_root / name
+        if path.is_file():
+            candidates.append(path.relative_to(repo_root))
+    return sorted(set(candidates), key=lambda item: item.as_posix())
+
+
+def score_path_against_goal(path: Path, tokens: set[str]) -> tuple[int, list[str]]:
+    if not tokens:
+        return (0, [])
+    parts = path.parts
+    normalized_parts = {part.lower() for part in parts}
+    stem_tokens = split_identifier(path.stem)
+    path_tokens = split_identifier(path.as_posix())
+    matches = sorted(tokens.intersection(path_tokens).union(tokens.intersection(normalized_parts)))
+    score = 0
+    for token in matches:
+        score += 8
+        if token in stem_tokens:
+            score += 14
+        if token in normalized_parts:
+            score += 4
+    if "index" in stem_tokens and len(parts) > 2:
+        score += 2
+    if path.name in {"index.js", "index.ts"} and len(parts) <= 2:
+        score -= 6
+    return score, matches
+
+
+def infer_files_from_goal(repo_root: Path, goal: str) -> list[str]:
+    tokens = goal_terms(goal)
+    scored = []
+    for candidate in source_candidates(repo_root):
+        score, matches = score_path_against_goal(candidate, tokens)
+        if score > 0:
+            scored.append((score, len(matches), -len(candidate.parts), candidate.as_posix(), matches))
+    if not scored:
+        return []
+    scored.sort(reverse=True)
+    best = scored[0]
+    # Refuse ambiguous guesses instead of spending a model call on the wrong file.
+    if len(scored) > 1 and scored[1][0] >= best[0] - 3:
+        return []
+    if best[0] < 10:
+        return []
+    return [best[3]]
+
+
+def infer_toy_source_file(repo_root: Path) -> list[str]:
+    preferred = [
+        "src/math.js",
+        "src/index.js",
+        "src/main.js",
+        "src/app.js",
+        "index.js",
+        "main.js",
+    ]
+    for item in preferred:
+        if (repo_root / item).is_file():
+            # Keep the original toy fixture ergonomic, but avoid broad-repo first-file guesses.
+            candidates = source_candidates(repo_root)
+            if len(candidates) <= 3:
+                return [item]
+            return []
+    candidates = source_candidates(repo_root)
+    if len(candidates) == 1:
+        return [candidates[0].as_posix()]
+    return []
+
+
+def infer_declared_files(repo_root: Path, requested: list[str], goal: str = "") -> list[str]:
+    if requested:
+        declared = [str(Path(item).as_posix()).lstrip("/") for item in requested]
+    else:
+        declared = infer_files_from_goal(repo_root, goal)
+        if not declared:
+            declared = infer_toy_source_file(repo_root)
+    if not declared:
+        raise SystemExit(
+            "Cannot determine a safe source file scope from the bug description. "
+            "Pass --declared-file path/to/file."
+        )
+    if len(declared) > 2:
+        raise SystemExit("The first Creator slice accepts at most two --declared-file values.")
+    missing = [path for path in declared if not (repo_root / path).is_file()]
+    if missing:
+        raise SystemExit(f"Declared file does not exist: {', '.join(missing)}")
+    return declared
+
+
+def product_fix_plan(
+    goal: str,
+    repo_root: Path,
+    requested_files: list[str],
+    recurrence: dict[str, Any] | None = None,
+    retrieval_mode: str = "exact",
+) -> dict[str, Any]:
+    declared_files = infer_declared_files(repo_root, requested_files, goal)
+    return {
+        "version": 1,
+        "goal": goal,
+        "source": "product_fix_first_creator_slice",
+        "tasks": [
+            {
+                "id": "task-002",
+                "description": goal,
+                "acceptance": ["Creator produces a sandbox patch within the declared file set", "Repository test command passes in the staged overlay"],
+                "risk_tier": 1,
+                "status": "pending",
+                "depends_on": [],
+                "declared_files": declared_files,
+                "attempt_count": 0,
+                "produced_artifacts": [],
+                "recurrence": recurrence or {
+                    "status": "recurrence_key_unassignable",
+                    "reason": "structured_recurrence_card_not_supplied",
+                },
+                "retrieval_mode": retrieval_mode,
+            }
+        ],
+    }
+
+
+def latest_job(repo_root: Path) -> Path | None:
+    found = find_latest_incomplete_job(repo_root)
+    if found:
+        return found
+    root = job_root(repo_root)
+    if not root.exists():
+        return None
+    candidates = []
+    for job_dir in root.iterdir():
+        if job_dir.is_dir() and (job_dir / "events.jsonl").exists():
+            state = replay(read_events(job_dir / "events.jsonl"))
+            candidates.append((state.last_seq, job_dir))
+    if not candidates:
+        return None
+    return sorted(candidates, key=lambda item: item[0], reverse=True)[0][1]
+
+
+def default_reviewer_name(args: argparse.Namespace) -> str:
+    return str(getattr(args, "reviewer_name", None) or getpass.getuser() or "local-user")
+
+
+def latest_passed_task_id(repo_root: Path, job_id: str | None, requested: str | None = None) -> tuple[str, str]:
+    job_dir = job_root(repo_root) / job_id if job_id else latest_job(repo_root)
+    if not job_dir:
+        raise SystemExit(f"No Socra jobs found under {job_root(repo_root)}")
+    events = read_events(job_dir / "events.jsonl")
+    plan = materialize_plan_from_events(events, json.loads((job_dir / "plan.json").read_text(encoding="utf-8")) if (job_dir / "plan.json").exists() else {"tasks": []})
+    if requested:
+        return job_dir.name, requested
+    passed = [str(task.get("id")) for task in plan.get("tasks", []) if task.get("status") == "passed"]
+    if not passed:
+        raise SystemExit("No passed task is available for review/promote.")
+    return job_dir.name, passed[-1]
+
+
+def status_main(args: argparse.Namespace) -> int:
+    repo_root = require_git_repo(args.project.expanduser().resolve())
+    config = load_config(repo_root)
+    print(f"Project: {repo_root}")
+    print(f"Config: {config_path(repo_root)}")
+    print(f"Tool: {config.get('tool', 'unknown')} schema {config.get('schema_version')}")
+    project = config.get("project") if isinstance(config.get("project"), dict) else {}
+    print(f"Package manager: {project.get('package_manager') or 'not detected'}")
+    test_command = project.get("test_command")
+    print(f"Test command: {' '.join(test_command) if isinstance(test_command, list) else 'not detected'}")
+    model = config.get("model") if isinstance(config.get("model"), dict) else {}
+    print(f"Endpoint: {model.get('endpoint') or 'not configured'}")
+    print(f"Model: {model.get('model') or 'not configured'}")
+    print(f"Hosted fallback: {bool(model.get('hosted_fallback'))}")
+
+    job_dir = latest_job(repo_root)
+    if not job_dir:
+        print("Job: none")
+        return 0
+
+    events = read_events(job_dir / "events.jsonl")
+    state = replay(events)
+    plan = materialize_plan_from_events(events, json.loads((job_dir / "plan.json").read_text(encoding="utf-8")) if (job_dir / "plan.json").exists() else {"tasks": []})
+    print(f"Job: {state.job_id}")
+    print(f"Goal: {state.goal}")
+    print(f"Phase: {state.phase}")
+    print(f"Events: {len(events)}")
+    print(f"Active task: {state.active_task_id or 'none'}")
+    print(f"Completed tasks: {len(state.completed_tasks)}")
+    print(f"Blocked tasks: {len(state.blocked_tasks)}")
+    print(f"Ready tasks: {', '.join(ready_task_ids(plan)[:8]) or 'none'}")
+    interrupted = detect_interrupted_attempt(events)
+    if interrupted:
+        print(
+            "Interrupted attempt: "
+            f"{interrupted['task_id']} after {interrupted['last_event_type']} "
+            f"(seq {interrupted['last_event_seq']})"
+        )
+    if state.last_error:
+        print(f"Last error: {state.last_error}")
+    return 0
+
+
+def fix_main(args: argparse.Namespace) -> int:
+    repo_root = require_git_repo(args.project.expanduser().resolve())
+    config = load_config(repo_root)
+    endpoint_probe = {"ok": None, "status": "skipped_plan_only"} if args.plan_only else require_live_endpoint(config)
+    job_id = args.job_id or new_job_id(args.goal)
+    job_dir = job_root(repo_root) / job_id
+    if job_dir.exists():
+        raise SystemExit(f"Job already exists: {job_dir}")
+
+    recurrence = None
+    if args.recurrence_card:
+        try:
+            recurrence = load_recurrence_card(args.recurrence_card.expanduser().resolve())
+            repository = project_identity(repo_root).get("repository")
+            if not repository or normalize_repository(repository) != recurrence["recurrence_key"]["canonical_repository_identity"]:
+                raise ValueError("recurrence card repository does not match the target repository")
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            raise SystemExit(f"Invalid recurrence card: {exc}") from exc
+    plan = product_fix_plan(
+        args.goal,
+        repo_root,
+        args.declared_file or [],
+        recurrence=recurrence,
+        retrieval_mode=args.retrieval,
+    )
+    validate_task_graph(plan["tasks"])
+
+    with JobLock(job_dir / ".lock"):
+        for folder in ["artifacts", "patches", "sandbox", "checkpoints"]:
+            (job_dir / folder).mkdir(parents=True, exist_ok=True)
+
+        write_json(job_dir / "plan.json", plan)
+        log = JobEventLog(job_dir / "events.jsonl", job_id)
+        log.append("job_created", {"goal": args.goal, "project": str(repo_root), "source": "product_fix"})
+        log.append("config_loaded", {"path": str(config_path(repo_root).relative_to(repo_root)), "schema_version": config.get("schema_version")})
+        model = model_config(config)
+        budgets = config.get("budgets") if isinstance(config.get("budgets"), dict) else {}
+        log.append("creator_endpoint_health_checked", {"endpoint": model.get("endpoint"), "probe": endpoint_probe})
+        log.append(
+            "creator_configured",
+            {
+                "role": "creator",
+                "model_alias": model.get("model") or "unconfigured",
+                "model": model.get("model") or "unconfigured",
+                "endpoint": model.get("endpoint"),
+                "backend": "openai-compatible",
+                "temperature": 0.2,
+                "context_budget_tokens": budgets.get("context_budget_tokens"),
+                "max_output_tokens": budgets.get("max_output_tokens"),
+                "hosted_fallback": bool(model.get("hosted_fallback")),
+                "local_first": bool(model.get("local_first", True)),
+                "source": "socra_config",
+            },
+        )
+        log.append("plan_written", {"plan": "plan.json", "task_count": len(plan["tasks"])})
+        for task in plan["tasks"]:
+            log.append("task_added", task)
+        log.append(
+            "plan_committed",
+            {
+                "revision": 1,
+                "task_count": len(plan["tasks"]),
+                "task_hash": canonical_task_hash(plan["tasks"]),
+                "source": "product_fix_first_creator_slice",
+            },
+        )
+        if args.plan_only:
+            log.append("job_paused", {"reason": "plan_only_no_agent_execution"})
+
+        events = read_events(job_dir / "events.jsonl")
+        state = replay(events)
+        write_state_snapshot(job_dir / "job.json", state)
+        write_handoff(job_dir, state_to_json(state), plan)
+
+    print(f"Created fix job: {job_id}")
+    print(f"Project: {repo_root}")
+    print(f"Job dir: {job_dir}")
+    print(f"Phase: {state.phase}")
+    if args.plan_only:
+        print("Plan-only mode: no endpoint preflight or agent execution was run.")
+        print("Next: wydcode status")
+        return 0
+
+    run_code = job_run_next_main(argparse.Namespace(project=repo_root, job_id=job_id, task_id=None, allow_unimplemented=False))
+    if run_code != 0:
+        try:
+            trace_result = sync_job_traces(repo_root, job_dir)
+            if trace_result["index_failed"]:
+                print(f"Warning: {trace_result['index_failed']} trace event(s) are durable but not indexed; run `wydcode traces sync --project .`")
+        except Exception as exc:  # noqa: BLE001 - local failure remains authoritative if central export is unavailable.
+            print(f"Warning: rejected-attempt trace export failed; run `wydcode traces sync --project .`: {exc}")
+        return run_code
+
+    project = config.get("project") if isinstance(config.get("project"), dict) else {}
+    test_command = project.get("test_command")
+    if isinstance(test_command, list) and test_command:
+        command = " ".join(shlex.quote(str(part)) for part in test_command)
+        milestone_code = job_run_milestone_main(
+            argparse.Namespace(
+                project=repo_root,
+                job_id=job_id,
+                milestone_id="product-fix-tests",
+                command=command,
+                timeout_seconds=120,
+                prepare_deps="none",
+                deps_timeout_seconds=300,
+                allow_partial_smoke=True,
+                promotion_grade=False,
+            )
+        )
+        if milestone_code != 0:
+            try:
+                trace_result = sync_job_traces(repo_root, job_dir)
+                if trace_result["index_failed"]:
+                    print(f"Warning: {trace_result['index_failed']} trace event(s) are durable but not indexed; run `wydcode traces sync --project .`")
+            except Exception as exc:  # noqa: BLE001
+                print(f"Warning: rejected-attempt trace export failed; run `wydcode traces sync --project .`: {exc}")
+        return milestone_code
+    else:
+        print("Endpoint preflight: ok")
+        print("No test command detected; Creator sandbox attempt completed without repo test gate.")
+    print("Next: wydcode status")
+    return 0
+
+
+def review_main(args: argparse.Namespace) -> int:
+    repo_root = require_git_repo(args.project.expanduser().resolve())
+    load_config(repo_root)
+    job_id, task_id = latest_passed_task_id(repo_root, args.job_id, args.task_id)
+    return job_review_promotion_main(
+        argparse.Namespace(
+            project=repo_root,
+            job_id=job_id,
+            task_id=task_id,
+            reviewer_name=default_reviewer_name(args),
+            present_diff=True,
+            approve_source_promotion=False,
+            attest_reviewed=False,
+            notes=args.notes,
+        )
+    )
+
+
+def approve_main(args: argparse.Namespace) -> int:
+    repo_root = require_git_repo(args.project.expanduser().resolve())
+    load_config(repo_root)
+    job_id, task_id = latest_passed_task_id(repo_root, args.job_id, args.task_id)
+    behavior_preference = None
+    gene_evidence = None
+    if bool(args.behavior_card) != bool(args.heldout_evidence):
+        raise SystemExit("--behavior-card and --heldout-evidence must be supplied together")
+    if args.behavior_card:
+        try:
+            behavior_preference = load_behavior_preference(args.behavior_card.expanduser().resolve())
+            gene_evidence = load_gene_evidence(args.heldout_evidence.expanduser().resolve())
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            raise SystemExit(f"Invalid behavior or held-out evidence card: {exc}") from exc
+    return job_review_promotion_main(
+        argparse.Namespace(
+            project=repo_root,
+            job_id=job_id,
+            task_id=task_id,
+            reviewer_name=default_reviewer_name(args),
+            present_diff=False,
+            approve_source_promotion=True,
+            attest_reviewed=True,
+            notes=args.notes,
+            behavior_preference=behavior_preference,
+            gene_evidence=gene_evidence,
+        )
+    )
+
+
+def reject_main(args: argparse.Namespace) -> int:
+    repo_root = require_git_repo(args.project.expanduser().resolve())
+    load_config(repo_root)
+    job_id, task_id = latest_passed_task_id(repo_root, args.job_id, args.task_id)
+    return job_reject_promotion_main(
+        argparse.Namespace(
+            project=repo_root,
+            job_id=job_id,
+            task_id=task_id,
+            reviewer_name=default_reviewer_name(args),
+            reason=args.reason,
+            notes=args.notes,
+        )
+    )
+
+
+def promote_main(args: argparse.Namespace) -> int:
+    repo_root = require_git_repo(args.project.expanduser().resolve())
+    load_config(repo_root)
+    job_id, task_id = latest_passed_task_id(repo_root, args.job_id, args.task_id)
+    return job_promote_main(
+        argparse.Namespace(
+            project=repo_root,
+            job_id=job_id,
+            task_id=task_id,
+            execute=not args.preflight,
+        )
+    )