wydcode 0.4.3

package/socra_harness/job/planner.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+from .events import JobEvent
+
+
+def canonical_task_hash(tasks: list[dict[str, Any]]) -> str:
+    immutable_tasks = []
+    for task in tasks:
+        immutable = {
+            "id": task.get("id"),
+            "description": task.get("description"),
+            "acceptance": task.get("acceptance", []),
+            "risk_tier": task.get("risk_tier"),
+            "depends_on": task.get("depends_on", []),
+            "declared_files": task.get("declared_files", []),
+        }
+        if "recurrence" in task:
+            immutable["recurrence"] = task.get("recurrence")
+        if "retrieval_mode" in task:
+            immutable["retrieval_mode"] = task.get("retrieval_mode")
+        immutable_tasks.append(immutable)
+    payload = json.dumps(immutable_tasks, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def task_event_payload(task: dict[str, Any]) -> dict[str, Any]:
+    required = {
+        "id",
+        "description",
+        "acceptance",
+        "risk_tier",
+        "status",
+        "depends_on",
+        "declared_files",
+        "attempt_count",
+        "produced_artifacts",
+    }
+    missing = required - set(task)
+    if missing:
+        raise ValueError(f"task missing required fields: {sorted(missing)}")
+    return dict(task)
+
+
+def validate_task_graph(tasks: list[dict[str, Any]]) -> None:
+    ids: set[str] = set()
+    for task in tasks:
+        payload = task_event_payload(task)
+        task_id = str(payload.get("id"))
+        if task_id in ids:
+            raise ValueError(f"duplicate task id: {task_id}")
+        ids.add(task_id)
+    for task in tasks:
+        task_id = str(task.get("id"))
+        for dep in task.get("depends_on", []):
+            if str(dep) not in ids:
+                raise ValueError(f"task {task_id} depends on unknown task: {dep}")
+
+
+def materialize_plan_from_events(events: list[JobEvent], fallback_plan: dict[str, Any] | None = None) -> dict[str, Any]:
+    goal = ""
+    tasks: list[dict[str, Any]] = []
+    committed: dict[str, Any] | None = None
+    revision = 0
+    by_id: dict[str, dict[str, Any]] = {}
+    task_statuses: dict[str, str] = {}
+    task_attempts: dict[str, int] = {}
+    task_artifacts: dict[str, list[dict[str, Any]]] = {}
+
+    for event in events:
+        if event.type == "job_created":
+            goal = str(event.payload.get("goal") or goal)
+        elif event.type == "plan_revised":
+            tasks = []
+            by_id = {}
+            committed = None
+            revision += 1
+        elif event.type == "task_added":
+            task = task_event_payload(event.payload)
+            task_id = str(task["id"])
+            if task_id in task_statuses:
+                task["status"] = task_statuses[task_id]
+            if task_id in task_attempts:
+                task["attempt_count"] = task_attempts[task_id]
+            if task_id in task_artifacts:
+                task["produced_artifacts"] = task_artifacts[task_id]
+            tasks.append(task)
+            by_id[task_id] = task
+        elif event.type == "plan_committed":
+            committed = dict(event.payload)
+            revision = int(committed.get("revision") or revision or 1)
+        elif event.type == "task_started":
+            task_id = str(event.payload.get("task_id") or "")
+            task_attempts[task_id] = task_attempts.get(task_id, 0) + 1
+            task = by_id.get(task_id)
+            if task:
+                task["status"] = "running"
+                task["attempt_count"] = task_attempts[task_id]
+        elif event.type == "task_artifacts":
+            task_id = str(event.payload.get("task_id") or "")
+            task_artifacts[task_id] = list(event.payload.get("artifacts") or [])
+            task = by_id.get(task_id)
+            if task:
+                task["produced_artifacts"] = task_artifacts[task_id]
+        elif event.type == "task_passed":
+            task_id = str(event.payload.get("task_id") or "")
+            task_statuses[task_id] = "passed"
+            task = by_id.get(task_id)
+            if task:
+                task["status"] = "passed"
+        elif event.type in {"task_failed", "declared_file_violation"}:
+            task_id = str(event.payload.get("task_id") or "")
+            task_statuses[task_id] = "failed"
+            task = by_id.get(task_id)
+            if task:
+                task["status"] = "failed"
+        elif event.type == "task_retry_scheduled":
+            task_id = str(event.payload.get("task_id") or "")
+            task_statuses[task_id] = "pending"
+            task = by_id.get(task_id)
+            if task:
+                task["status"] = "pending"
+        elif event.type == "task_blocked":
+            task_id = str(event.payload.get("task_id") or "")
+            task_statuses[task_id] = "blocked"
+            task = by_id.get(task_id)
+            if task:
+                task["status"] = "blocked"
+
+    if not tasks:
+        return fallback_plan or {"version": 1, "goal": goal, "tasks": []}
+
+    plan = {
+        "version": 1,
+        "goal": goal,
+        "revision": revision or 1,
+        "source": "task_added_events",
+        "tasks": tasks,
+        "task_count": len(tasks),
+        "task_hash": canonical_task_hash(tasks),
+    }
+    if committed:
+        plan["committed"] = committed
+    return plan
+
+
+def ready_task_ids(plan: dict[str, Any]) -> list[str]:
+    tasks = plan.get("tasks") if isinstance(plan.get("tasks"), list) else []
+    by_id = {str(task.get("id")): task for task in tasks}
+    passed = {task_id for task_id, task in by_id.items() if task.get("status") in {"passed", "skipped"}}
+    ready: list[str] = []
+    for task in tasks:
+        if task.get("status") != "pending":
+            continue
+        deps = [str(dep) for dep in task.get("depends_on", [])]
+        if all(dep in passed for dep in deps):
+            ready.append(str(task.get("id")))
+    return ready
+
+
+def mumpix_dashboard_tasks() -> list[dict[str, Any]]:
+    def task(
+        idx: int,
+        description: str,
+        acceptance: list[str],
+        risk: int,
+        files: list[str],
+        deps: list[str] | None = None,
+    ) -> dict[str, Any]:
+        return {
+            "id": f"task-{idx:03d}",
+            "description": description,
+            "acceptance": acceptance,
+            "risk_tier": risk,
+            "status": "pending",
+            "depends_on": deps or [],
+            "declared_files": files,
+            "attempt_count": 0,
+            "produced_artifacts": [],
+        }
+
+    return [
+        task(1, "Inventory existing Mumpix frontend routes, APIs, and data files.", ["Inventory report lists usable API endpoints", "Declared dashboard data sources are named"], 0, ["App.jsx", "server.js", "mumpixdb-core.js", "package.json"]),
+        task(2, "Define dashboard navigation and information architecture.", ["Dashboard sections cover WAL, genes/routes, benchmarks, and status", "Navigation labels are fixed before UI work"], 0, ["App.jsx"], ["task-001"]),
+        task(3, "Define local admin API contract and artifact discovery plan.", ["Contract includes WAL/events, gene/route, benchmark, and health payloads", "Plan lists local globs, excludes large/vendor paths, and avoids hosted dependencies"], 0, ["server.js"], ["task-001"]),
+        task(4, "Document dashboard milestone gates and preview command.", ["Runner command is identified", "Milestone acceptance checks are written"], 0, ["README.md", "package.json"], ["task-001"]),
+        task(5, "Add server utility for safe local artifact reads.", ["Malformed files return structured errors", "Reads stay inside local project/data roots"], 2, ["server.js"], ["task-003"]),
+        task(6, "Add WAL/event artifact adapter.", ["Adapter reads .wal/.ndjson event files", "Payload normalizes timestamp, key, type, and summary fields"], 2, ["server.js"], ["task-005"]),
+        task(7, "Add gene and route artifact adapter.", ["Adapter finds likely gene/route files", "Payload includes id, family, status, and source path"], 2, ["server.js"], ["task-005"]),
+        task(
+            8,
+            "Create standalone safe artifact reader module.",
+            [
+                "server/admin/artifactReaders.js provides safe local artifact read helpers",
+                "Existing safe-read behavior from task 005 is retained",
+            ],
+            2,
+            ["server/admin/artifactReaders.js"],
+            ["task-007"],
+        ),
+        task(36, "Extract WAL/event artifact adapter into a module.", ["Adapter reads .wal/.ndjson event files", "Payload normalizes timestamp, key, type, and summary fields"], 2, ["server/admin/walAdapter.js", "server/admin/artifactReaders.js"], ["task-008"]),
+        task(37, "Extract gene and route artifact adapter into a module.", ["Adapter finds likely gene/route files", "Payload includes id, family, status, and source path"], 2, ["server/admin/geneRouteAdapter.js", "server/admin/artifactReaders.js"], ["task-008"]),
+        task(9, "Add benchmark/result artifact adapter.", ["Adapter finds benchmark JSON/markdown summaries", "Payload includes name, score, date, and source path"], 2, ["server/admin/benchmarkAdapter.js", "server/admin/artifactReaders.js"], ["task-008"]),
+        task(10, "Expose admin health endpoint.", ["Endpoint reports local-only mode and artifact counts", "Endpoint has deterministic empty-state payload"], 2, ["server.js", "server/admin/artifactReaders.js"], ["task-008"]),
+        task(11, "Expose admin WAL/events endpoint.", ["Endpoint returns paginated normalized events", "Endpoint handles missing data without crashing"], 2, ["server.js", "server/admin/walAdapter.js"], ["task-036"]),
+        task(12, "Expose admin genes/routes endpoint.", ["Endpoint returns normalized gene/route rows", "Endpoint exposes source file path for inspection"], 2, ["server.js", "server/admin/geneRouteAdapter.js"], ["task-037"]),
+        task(35, "Expose admin benchmark/results endpoint.", ["Endpoint returns normalized benchmark cards", "Endpoint handles mixed JSON/markdown inputs"], 2, ["server.js", "server/admin/benchmarkAdapter.js"], ["task-009"]),
+        task(13, "Create dashboard data client helpers.", ["Frontend helpers fetch admin endpoints", "Errors are represented as UI-friendly objects"], 2, ["App.jsx"], ["task-010", "task-011", "task-012", "task-035"]),
+        task(14, "Create App.jsx dashboard decomposition boundary.", ["Dashboard additions have a named boundary inside or beside the existing monolith", "Future UI tasks do not require understanding the whole 1371-line file at once"], 2, ["App.jsx"], ["task-002", "task-013"]),
+        task(15, "Create dashboard shell layout.", ["Shell has header, nav, and main content region", "Existing manual memory UI remains reachable or is intentionally replaced"], 2, ["App.jsx", "styles.css"], ["task-014"]),
+        task(16, "Add overview cards for local health and artifact counts.", ["Cards show WAL, gene/route, benchmark, and error counts", "Empty state is visible"], 2, ["App.jsx"], ["task-015"]),
+        task(17, "Add WAL/event timeline panel.", ["Timeline lists recent events with readable summaries", "Filtering by type/source exists"], 2, ["App.jsx", "styles.css"], ["task-010", "task-015"]),
+        task(18, "Add gene inspector panel.", ["Inspector lists genes/routes and key metadata", "Selecting a row shows detail"], 2, ["App.jsx", "styles.css"], ["task-011", "task-015"]),
+        task(19, "Add route-fire timeline panel.", ["Panel visualizes route/gene activation-like rows where available", "No data state explains what is missing"], 2, ["App.jsx", "styles.css"], ["task-011", "task-015"]),
+        task(20, "Add benchmark viewer panel.", ["Viewer shows benchmark cards and detail", "Scores and source paths are visible"], 2, ["App.jsx", "styles.css"], ["task-035", "task-015"]),
+        task(21, "Add local file/source detail drawer.", ["Drawer shows selected artifact metadata", "Dangerous raw rendering is escaped"], 2, ["App.jsx", "styles.css"], ["task-017", "task-018", "task-020"]),
+        task(22, "Add loading and error state components.", ["All admin panels have loading and error states", "Retry action is available"], 2, ["App.jsx", "styles.css"], ["task-015"]),
+        task(23, "Add lightweight chart primitives and overview metric bars without new dependency.", ["Bar/timeline visuals render from CSS/React", "Overview values match fetched artifact counts"], 2, ["App.jsx", "styles.css"], ["task-016"]),
+        task(24, "Wire chart primitives into benchmark viewer.", ["Benchmarks display compact score visuals", "Missing scores do not break layout"], 2, ["App.jsx", "styles.css"], ["task-020", "task-023"]),
+        task(25, "Add live-tail polling for admin data.", ["Refresh interval can be started/stopped", "Polling does not duplicate rows"], 2, ["App.jsx"], ["task-017", "task-018", "task-020"]),
+        task(26, "Add WebSocket live-tail integration if existing server broadcast supports it.", ["Uses existing WebSocket server only", "Falls back to polling when unavailable"], 3, ["server.js", "App.jsx"], ["task-025"]),
+        task(27, "Add dashboard search across events, genes, routes, and benchmarks.", ["Search filters all visible panels", "Search handles empty query and special characters"], 2, ["App.jsx"], ["task-017", "task-018", "task-020"]),
+        task(28, "Run frontend syntax and build gate.", ["Runner records syntax/build notes", "Build artifacts are not treated as source truth"], 3, ["package.json", "vite.config.js"], ["task-015", "task-022"]),
+        task(29, "Run backend API smoke checks in sandbox.", ["Health endpoint responds", "Admin endpoints return JSON"], 3, ["server.js"], ["task-010", "task-011", "task-012", "task-035"]),
+        task(30, "Preview dashboard and record smoke evidence.", ["Preview page loads", "At least three dashboard sections render"], 3, ["App.jsx", "styles.css"], ["task-028", "task-029"]),
+        task(31, "Write dashboard usage docs.", ["README explains running dashboard", "Docs mention local-only artifact inspection"], 2, ["README.md"], ["task-030"]),
+        task(32, "Prepare atomic promotion patch bundle.", ["Patch bundle lists all changed files", "Rollback manifest exists"], 5, [], ["task-030", "task-031"]),
+        task(33, "Run final promotion gate.", ["Build and smoke checks pass after promotion candidate", "No hosted calls are required"], 5, ["package.json"], ["task-032"]),
+        task(34, "Write stress-test outcome report.", ["Report compares actual task count and interventions to prereg", "Report states allowed and blocked claims"], 2, ["README.md"], ["task-033"]),
+    ]
+
+
+def planner_tasks_for_goal(goal: str, project: Path) -> list[dict[str, Any]]:
+    text = f"{goal} {project}".lower()
+    if "mumpix" in text and "dashboard" in text:
+        return mumpix_dashboard_tasks()
+    return [
+        {
+            "id": "task-001",
+            "description": "Inventory the project and produce a concrete task DAG.",
+            "acceptance": ["Project files are inventoried", "Next task graph can be generated from evidence"],
+            "risk_tier": 0,
+            "status": "pending",
+            "depends_on": [],
+            "declared_files": [],
+            "attempt_count": 0,
+            "produced_artifacts": [],
+        }
+    ]

package/socra_harness/job/state.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+from pathlib import Path
+from typing import Any
+
+from .events import JobEvent, read_events
+
+
+@dataclasses.dataclass
+class JobState:
+    job_id: str
+    goal: str
+    phase: str
+    project: str
+    active_task_id: str | None
+    completed_tasks: list[str]
+    blocked_tasks: list[str]
+    last_error: str | None
+    creator_config: dict[str, Any] | None
+    last_seq: int
+
+
+def initial_state() -> JobState:
+    return JobState(
+        job_id="",
+        goal="",
+        phase="created",
+        project="",
+        active_task_id=None,
+        completed_tasks=[],
+        blocked_tasks=[],
+        last_error=None,
+        creator_config=None,
+        last_seq=0,
+    )
+
+
+def apply_event(state: JobState, event: JobEvent) -> JobState:
+    state.last_seq = event.seq
+    state.job_id = event.job_id
+    payload = event.payload
+    if event.type == "job_created":
+        state.goal = str(payload.get("goal", state.goal))
+        state.project = str(payload.get("project", state.project))
+        state.phase = "planning"
+    elif event.type == "plan_written":
+        state.phase = "paused"
+    elif event.type == "phase_changed":
+        state.phase = str(payload.get("phase", state.phase))
+    elif event.type == "task_started":
+        state.phase = "executing"
+        state.active_task_id = str(payload.get("task_id") or "")
+    elif event.type == "creator_configured":
+        state.creator_config = dict(payload)
+    elif event.type == "task_passed":
+        task_id = str(payload.get("task_id") or "")
+        if task_id and task_id not in state.completed_tasks:
+            state.completed_tasks.append(task_id)
+        if state.active_task_id == task_id:
+            state.active_task_id = None
+        state.phase = "paused"
+    elif event.type == "task_failed":
+        task_id = str(payload.get("task_id") or "")
+        if state.active_task_id == task_id:
+            state.active_task_id = None
+        state.last_error = str(payload.get("error") or "")
+        state.phase = "paused"
+    elif event.type == "task_retry_scheduled":
+        state.phase = "paused"
+        state.active_task_id = None
+    elif event.type == "task_blocked":
+        task_id = str(payload.get("task_id") or "")
+        if task_id and task_id not in state.blocked_tasks:
+            state.blocked_tasks.append(task_id)
+        state.last_error = str(payload.get("error") or "")
+        state.phase = "blocked"
+    elif event.type == "job_paused":
+        state.phase = "paused"
+    elif event.type == "job_completed":
+        state.phase = "done"
+        state.active_task_id = None
+    elif event.type == "job_failed":
+        state.phase = "failed"
+        state.last_error = str(payload.get("error") or "")
+    return state
+
+
+def replay(events: list[JobEvent]) -> JobState:
+    state = initial_state()
+    for event in events:
+        apply_event(state, event)
+    return state
+
+
+def replay_path(path: Path) -> JobState:
+    return replay(read_events(path))
+
+
+def state_to_json(state: JobState) -> dict[str, Any]:
+    return dataclasses.asdict(state)
+
+
+def write_state_snapshot(path: Path, state: JobState) -> None:
+    path.write_text(json.dumps(state_to_json(state), indent=2) + "\n", encoding="utf-8")

package/socra_harness/mumpix_trace_bridge.cjs

@@ -0,0 +1,32 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { Mumpix } = require("mumpix");
+
+async function main() {
+  const dbPath = process.argv[2];
+  if (!dbPath) throw new Error("mumpix trace bridge requires a database path");
+  process.env.MUMPIX_LICENSE_WATERMARK_PATH ||= path.join(path.dirname(dbPath), ".mumpix-license-watermark.json");
+  const input = fs.readFileSync(0, "utf8");
+  const event = JSON.parse(input);
+  const payload = event.payload || {};
+  const project = payload.project || {};
+  const db = await Mumpix.open(dbPath, { consistency: "eventual", telemetry: false });
+  try {
+    const result = await db.remember(JSON.stringify(event), {
+      workspace: "wydcode-cross-project-traces",
+      repo: project.repository_name || project.project_scope_id || "unknown",
+      source: "wydcode:validated-fix-trace",
+      ts: Date.parse(event.timestamp) || Date.now(),
+    });
+    process.stdout.write(JSON.stringify({ ok: true, record_id: String(result.id), consistency: result.consistency }));
+  } finally {
+    await db.close();
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(String(error && error.stack ? error.stack : error));
+  process.exitCode = 1;
+});