wydcode 0.4.3

package/bin/wydcode.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+const path = require('node:path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const cliName = path.basename(process.argv[1] || '').includes('wydcode') ? 'wydcode' : 'socra-harness';
+const candidates = [
+  process.env.SOCRA_PYTHON,
+  'python3.12',
+  'python3.11',
+  'python3',
+].filter(Boolean);
+
+function run(candidate, args, options = {}) {
+  return spawnSync(candidate, args, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      SOCRA_CLI_NAME: process.env.SOCRA_CLI_NAME || cliName,
+      SOCRA_CLI_NAME: 'wydcode',
+      PYTHONPATH: [packageRoot, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter),
+    },
+    encoding: 'utf8',
+    ...options,
+  });
+}
+
+let selected = null;
+let lastError = '';
+
+for (const candidate of candidates) {
+  const probe = run(candidate, [
+    '-c',
+    'import sys; raise SystemExit(0 if sys.version_info >= (3, 11) else 42)',
+  ]);
+  if (probe.status === 0) {
+    selected = candidate;
+    break;
+  }
+  if (probe.error) {
+    lastError = String(probe.error.message || probe.error);
+  } else if (probe.status === 42) {
+    lastError = `${candidate} is older than Python 3.11`;
+  } else if (probe.stderr) {
+    lastError = probe.stderr.trim();
+  }
+}
+
+if (!selected) {
+  console.error(`${cliName} requires Python 3.11+.`);
+  console.error('Install Python 3.11+ or set SOCRA_PYTHON=/path/to/python.');
+  if (lastError) {
+    console.error(`Last probe: ${lastError}`);
+  }
+  process.exit(1);
+}
+
+const result = run(selected, ['-m', 'socra_harness.cli', ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  encoding: undefined,
+});
+
+if (result.error) {
+  console.error(`Failed to run ${cliName} with ${selected}: ${result.error.message}`);
+  process.exit(1);
+}
+
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+}
+
+process.exit(typeof result.status === 'number' ? result.status : 1);

package/examples/behavior-preference-card.json

@@ -0,0 +1,12 @@
+{
+  "approach": "Preserve the arithmetic contract while correcting the failing branch.",
+  "invariants_to_preserve": [
+    "Inputs remain immutable and ordinary numeric addition remains unchanged."
+  ],
+  "checks_to_run": [
+    "Exercise positive, negative, and zero operands through the public API."
+  ],
+  "known_nonmatches": [
+    "Do not apply this behavior to multiplication or string concatenation failures."
+  ]
+}

package/examples/exact-recurrence-card.json

@@ -0,0 +1,11 @@
+{
+  "card_id": "math-add-terminal-assertion-v1",
+  "repository_identity": "github.com/mumpix/wydcode",
+  "owning_path": "src/math.js",
+  "owning_symbol_or_api": "add",
+  "invariant": {
+    "error_or_assertion_class": "AssertionError",
+    "operation": "add two numeric operands",
+    "expected_relation": "result equals the arithmetic sum"
+  }
+}

package/examples/heldout-gene-evidence.json

@@ -0,0 +1,6 @@
+{
+  "status": "passed",
+  "probe_sha256": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "hidden_feedback_used": false,
+  "description": "Replace probe_sha256 with the SHA-256 of the real held-out result artifact."
+}

package/examples/humaneval-ornith.md

@@ -0,0 +1,29 @@
+# Example: Ornith HumanEval with wydcode
+
+```bash
+MODEL_PATH="$HOME/models/ornith-1.0-35b-Q6_K.gguf"
+LLAMA_CLI="$HOME/src/llama.cpp/build/bin/llama-cli"
+TASKS_PATH="$HOME/benchmarks/humaneval-openai-full-164.jsonl"
+
+wydcode eval humaneval \
+  --name ornith \
+  --model "$MODEL_PATH" \
+  --llama-cli "$LLAMA_CLI" \
+  --tasks "$TASKS_PATH" \
+  --mode socra \
+  --gpu-layers 999 \
+  --no-cpu-fallback
+```
+
+Known local result from the corrected harness:
+
+- `145/164`
+- pass@1 `0.8841`
+- GPU generations `164/164`
+- CPU fallback `0/164`
+
+Open the terminal UI in another shell:
+
+```bash
+wydcode tui --state-dir .socra
+```

package/examples/large_context_json_diagnostic.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from socra_harness.job.events import JobEventLog, read_events
+from socra_harness.job.lock import JobLock
+from socra_harness.job.manager import (
+    CREATOR_PROMPT_LAYOUT,
+    build_creator_messages,
+    call_creator_model,
+    declared_file_set,
+    endpoint_health,
+    latest_passed_artifacts_by_path,
+    load_plan,
+    parse_creator_json,
+    read_declared_file_context,
+    sha256_file,
+    sha256_text,
+    validate_creator_declared_files,
+)
+from socra_harness.job.planner import materialize_plan_from_events
+from socra_harness.job.state import replay
+
+
+def elapsed_ms(start: float) -> int:
+    return int(round((time.monotonic() - start) * 1000))
+
+
+def write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run a large-context JSON-contract diagnostic against a Socra job.")
+    parser.add_argument("--project", required=True, type=Path)
+    parser.add_argument("--job-id", required=True)
+    parser.add_argument("--diagnostic-id", default="large-context-json-v1")
+    parser.add_argument(
+        "--declared-file",
+        action="append",
+        dest="declared_files",
+        default=[],
+        help="Relative file to include. Repeatable. Defaults to the server decomposition stress shape.",
+    )
+    args = parser.parse_args()
+
+    project = args.project.expanduser().resolve()
+    job_dir = project / ".socra" / "jobs" / args.job_id
+    declared_files = args.declared_files or [
+        "server.js",
+        "server/admin/artifactReaders.js",
+        "server/admin/walAdapter.js",
+        "server/admin/geneRouteAdapter.js",
+    ]
+
+    with JobLock(job_dir / ".lock"):
+        events = read_events(job_dir / "events.jsonl")
+        state = replay(events)
+        plan = materialize_plan_from_events(events, load_plan(job_dir))
+        creator = state.creator_config or {}
+        log = JobEventLog(job_dir / "events.jsonl", state.job_id or args.job_id)
+
+        health = endpoint_health(str(creator.get("endpoint") or "http://127.0.0.1:11439/v1"))
+        expected_model = str(creator.get("expected_served_model_id") or Path(str(creator.get("model") or "")).name)
+        if expected_model:
+            served_ids = [str(item) for item in health.get("model_ids") or []]
+            health["expected_served_model_id"] = expected_model
+            health["model_identity_ok"] = expected_model in served_ids
+            health["served_model_ids"] = served_ids
+
+        task = {
+            "id": args.diagnostic_id,
+            "description": (
+                "Diagnostic only: test whether the current Creator configuration can return valid JSON "
+                "for a large multi-file context. Preserve existing behavior and return full file contents."
+            ),
+            "acceptance": [
+                "response is valid Creator JSON",
+                "all returned paths stay within declared files",
+                "finish_reason indicates a complete response",
+            ],
+            "risk_tier": 0,
+            "declared_files": declared_files,
+        }
+
+        effective_sources = latest_passed_artifacts_by_path(job_dir, plan)
+        file_context = read_declared_file_context(project, task, effective_sources)
+        context_sources = [
+            {
+                "path": item.get("path"),
+                "source": item.get("source"),
+                "source_task_id": item.get("source_task_id"),
+                "sandbox_path": item.get("sandbox_path"),
+                "sha256": item.get("sha256"),
+                "exists": item.get("exists"),
+                "content_chars": len(str(item.get("content") or "")),
+            }
+            for item in file_context
+        ]
+
+        artifact_dir = job_dir / "artifacts" / "diagnostics" / args.diagnostic_id
+        artifact_dir.mkdir(parents=True, exist_ok=True)
+        messages = build_creator_messages(job_dir, project, task, file_context, retry_feedback=[])
+        request_path = artifact_dir / "creator-request.json"
+        write_json(request_path, {"messages": messages})
+
+        start_event = log.append(
+            "large_context_json_diagnostic_started",
+            {
+                "diagnostic_id": args.diagnostic_id,
+                "declared_files": declared_files,
+                "context_sources": context_sources,
+                "prompt_layout": CREATOR_PROMPT_LAYOUT,
+                "request_path": str(request_path.relative_to(job_dir)),
+                "request_sha256": sha256_file(request_path),
+                "endpoint_health": health,
+            },
+        )
+
+        response: dict[str, Any] | None = None
+        parse_ok = False
+        violations: list[str] = []
+        parse_error = ""
+        creator_call_start = time.monotonic()
+        try:
+            if not health.get("ok") or not health.get("model_identity_ok"):
+                raise RuntimeError("diagnostic_endpoint_unavailable_or_model_mismatch")
+            response = call_creator_model(creator, messages, json_mode=True)
+            payload = parse_creator_json(str(response.get("content") or ""))
+            violations = validate_creator_declared_files(payload, declared_file_set(task))
+            parse_ok = not violations
+        except Exception as exc:  # noqa: BLE001 - diagnostic records failures instead of raising.
+            parse_error = str(exc)
+        creator_call_ms = elapsed_ms(creator_call_start)
+
+        response_path = artifact_dir / "creator-response.json"
+        write_json(response_path, response or {"error": parse_error})
+
+        finish_reason = response.get("finish_reason") if response else None
+        if parse_ok and finish_reason == "stop":
+            verdict = "pass_large_context_json_current_config"
+        elif finish_reason == "length":
+            verdict = "fail_probable_truncation"
+        elif finish_reason == "stop":
+            verdict = "fail_large_context_json_contract_despite_complete_response"
+        else:
+            verdict = "fail_incomplete_or_unclassified_response"
+
+        result = {
+            "diagnostic_id": args.diagnostic_id,
+            "started_event_seq": start_event.seq,
+            "declared_files": declared_files,
+            "context_sources": context_sources,
+            "prompt_layout": CREATOR_PROMPT_LAYOUT,
+            "request_path": str(request_path.relative_to(job_dir)),
+            "request_sha256": sha256_file(request_path),
+            "response_path": str(response_path.relative_to(job_dir)),
+            "response_sha256": sha256_file(response_path),
+            "creator_call_ms": creator_call_ms,
+            "request_model": response.get("request_model") if response else None,
+            "response_model": response.get("response_model") if response else None,
+            "content_sha256": sha256_text(str(response.get("content") or "")) if response else None,
+            "content_chars": len(str(response.get("content") or "")) if response else 0,
+            "reasoning_chars": len(str(response.get("reasoning_content") or "")) if response else 0,
+            "finish_reason": finish_reason,
+            "usage": response.get("usage") if response and isinstance(response.get("usage"), dict) else {},
+            "parse_ok": parse_ok,
+            "declared_file_violations": violations,
+            "parse_error": parse_error,
+            "verdict": verdict,
+        }
+        result_path = artifact_dir / "result.json"
+        write_json(result_path, result)
+        log.append("large_context_json_diagnostic_completed", {**result, "result_path": str(result_path.relative_to(job_dir)), "result_sha256": sha256_file(result_path)})
+
+    print(json.dumps(result, indent=2))
+    return 0 if parse_ok else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

package/fixtures/failing-node-repo/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "socra-failing-node-fixture",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/fixtures/failing-node-repo/src/math.js

@@ -0,0 +1,3 @@
+export function add(a, b) {
+  return a - b;
+}

package/fixtures/failing-node-repo/test/math.test.js

@@ -0,0 +1,8 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { add } from "../src/math.js";
+
+test("add returns the arithmetic sum", () => {
+  assert.equal(add(2, 3), 5);
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "wydcode",
+  "version": "0.4.3",
+  "description": "Local-first long-running bug fixer: staged AI patches behind hash-bound human review.",
+  "license": "BUSL-1.1",
+  "author": "Mumpix",
+  "type": "commonjs",
+  "bin": {
+    "wydcode": "bin/wydcode.js",
+    "socra-harness": "bin/wydcode.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/wydcode.js",
+    "SOCRA_SOURCE.md",
+    "examples/*.json",
+    "examples/*.md",
+    "examples/*.py",
+    "fixtures",
+    "socra_harness/**/*.py",
+    "socra_harness/**/*.cjs",
+    "README.md",
+    "SECURITY.md",
+    "NOTICE",
+    "TRADEMARKS.md",
+    "pyproject.toml",
+    "LICENSE"
+  ],
+  "keywords": [
+    "coding-agent",
+    "bug-fixer",
+    "local-first",
+    "code-review",
+    "ai",
+    "automation",
+    "socra",
+    "mumpix"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mumpix/wydcode.git"
+  },
+  "homepage": "https://github.com/mumpix/wydcode",
+  "bugs": {
+    "url": "https://github.com/mumpix/wydcode/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "mumpix": "^1.1.3"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wydcode"
+version = "0.4.3"
+description = "Local-first long-running bug fixer with hash-bound human review."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{name = "Mumpix"}]
+license = {text = "BUSL-1.1"}
+dependencies = []
+
+[project.scripts]
+wydcode = "socra_harness.cli:main"
+socra-harness = "socra_harness.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["socra_harness*"]
+
+[tool.setuptools.package-data]
+socra_harness = ["*.cjs"]

package/socra_harness/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.4.3"

package/socra_harness/attempts.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from .job.events import JobEvent
+
+
+class AttemptFailure(str, Enum):
+    LENGTH_DEATH = "length_death"
+    MALFORMED_OUTPUT = "malformed_output"
+    GATE_FAILED = "gate_failed"
+    ENDPOINT_ERROR = "endpoint_error"
+    INTERRUPTED = "interrupted"
+
+
+IN_PROGRESS_EVENTS = {
+    "task_started",
+    "creator_request_written",
+    "creator_call_started",
+    "creator_output_received",
+    "patch_written",
+    "gate_started",
+}
+
+TERMINAL_EVENTS = {
+    "task_passed",
+    "task_failed",
+    "task_blocked",
+    "job_paused",
+    "job_completed",
+    "job_failed",
+    "job_interrupted",
+}
+
+
+def attempt_failure_payload(kind: AttemptFailure, **extra: Any) -> dict[str, Any]:
+    payload = {"failure_type": kind.value}
+    payload.update(extra)
+    return payload
+
+
+def classify_creator_finish(finish_reason: str | None) -> AttemptFailure | None:
+    if finish_reason == "length":
+        return AttemptFailure.LENGTH_DEATH
+    return None
+
+
+def detect_interrupted_attempt(events: list[JobEvent]) -> dict[str, Any] | None:
+    task_id: str | None = None
+    start_seq: int | None = None
+    last_in_progress: JobEvent | None = None
+
+    for event in events:
+        if event.type == "task_started":
+            task_id = str(event.payload.get("task_id") or "")
+            start_seq = event.seq
+            last_in_progress = event
+        elif task_id and event.type in IN_PROGRESS_EVENTS:
+            last_in_progress = event
+        elif event.type in TERMINAL_EVENTS:
+            event_task = str(event.payload.get("task_id") or "")
+            if not event_task or event_task == task_id:
+                task_id = None
+                start_seq = None
+                last_in_progress = None
+
+    if not task_id or not start_seq or last_in_progress is None:
+        return None
+    return {
+        "failure_type": AttemptFailure.INTERRUPTED.value,
+        "task_id": task_id,
+        "started_seq": start_seq,
+        "last_event_type": last_in_progress.type,
+        "last_event_seq": last_in_progress.seq,
+    }