devcouncil 0.2.0 → 0.2.1

package/src/devcouncil/telemetry/pricing.py

@@ -1,28 +0,0 @@
-from functools import lru_cache
-from importlib import resources
-from typing import Dict
-
-import yaml
-
-MODEL_PRICING_RESOURCE = "model_pricing.yaml"
-
-
-@lru_cache(maxsize=1)
-def load_model_pricing() -> Dict[str, Dict[str, float]]:
-    data = resources.files(__package__).joinpath(MODEL_PRICING_RESOURCE).read_text(encoding="utf-8")
-    loaded = yaml.safe_load(data) or {}
-    return {
-        str(model): {
-            "prompt_per_1k": float(pricing.get("prompt_per_1k", 0.0)),
-            "completion_per_1k": float(pricing.get("completion_per_1k", 0.0)),
-        }
-        for model, pricing in loaded.items()
-        if isinstance(pricing, dict)
-    }
-
-
-def pricing_for_model(model: str, default: Dict[str, float] | None = None) -> Dict[str, float]:
-    pricing = load_model_pricing().get(model)
-    if pricing is not None:
-        return pricing
-    return default or {"prompt_per_1k": 0.0, "completion_per_1k": 0.0}

package/src/devcouncil/telemetry/traces.py

@@ -1,146 +0,0 @@
-import json
-import logging
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Tuple
-
-from pydantic import BaseModel, ConfigDict, Field
-
-logger = logging.getLogger(__name__)
-
-TRACE_SCHEMA_VERSION = "devcouncil.trace.v1"
-
-
-class TraceEvent(BaseModel):
-    """Stable JSONL event shape for DevCouncil and external visualizers."""
-
-    model_config = ConfigDict(populate_by_name=True, serialize_by_alias=True)
-
-    schema_version: str = Field(TRACE_SCHEMA_VERSION, alias="schema")
-    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    timestamp: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
-    runtime: str = "devcouncil"
-    type: str
-    run_id: Optional[str] = None
-    task_id: Optional[str] = None
-    summary: str = ""
-    details: Dict[str, Any] = Field(default_factory=dict)
-
-    @classmethod
-    def from_legacy(cls, raw: Dict[str, Any]) -> "TraceEvent":
-        if raw.get("schema") == TRACE_SCHEMA_VERSION:
-            return cls.model_validate(raw)
-        raw_details = raw.get("details")
-        details: Dict[str, Any] = raw_details if isinstance(raw_details, dict) else {}
-        raw_task_id = details.get("task_id")
-        raw_summary = details.get("summary")
-        raw_run_id = raw.get("run_id")
-        return cls(
-            schema=TRACE_SCHEMA_VERSION,
-            type=str(raw.get("type", "legacy_event")),
-            run_id=raw_run_id if isinstance(raw_run_id, str) else None,
-            task_id=raw_task_id if isinstance(raw_task_id, str) else None,
-            summary=raw_summary if isinstance(raw_summary, str) else "",
-            details=details,
-        )
-
-
-class TraceLogger:
-    """Manages appending execution traces to a local log file."""
-
-    def __init__(self, project_root: Path):
-        self.log_dir = project_root / ".devcouncil" / "logs"
-        self.trace_file = self.log_dir / "traces.jsonl"
-        self.log_dir.mkdir(parents=True, exist_ok=True)
-
-    def log_event(
-        self,
-        event_type: str,
-        details: Dict[str, Any],
-        run_id: Optional[str] = None,
-        task_id: Optional[str] = None,
-        summary: str = "",
-    ) -> TraceEvent:
-        """Append an orchestration event trace."""
-        trace = TraceEvent(
-            schema=TRACE_SCHEMA_VERSION,
-            type=event_type,
-            details=details,
-            run_id=run_id,
-            task_id=task_id,
-            summary=summary,
-        )
-        try:
-            with open(self.trace_file, "a", encoding="utf-8") as f:
-                f.write(trace.model_dump_json() + "\n")
-        except Exception as e:
-            logger.debug("Failed to write trace event %s: %s", event_type, e)
-        return trace
-
-
-def read_trace_events(project_root: Path) -> Iterable[TraceEvent]:
-    trace_file = project_root / ".devcouncil" / "logs" / "traces.jsonl"
-    if not trace_file.exists():
-        return []
-
-    events: list[TraceEvent] = []
-    for line in trace_file.read_text(encoding="utf-8").splitlines():
-        if not line.strip():
-            continue
-        try:
-            events.append(TraceEvent.from_legacy(json.loads(line)))
-        except Exception as exc:
-            logger.debug("Skipping invalid trace line: %s", exc)
-    return events
-
-
-def read_trace_events_since(
-    project_root: Path, cursor: Optional[int] = None
-) -> Tuple[List[TraceEvent], int]:
-    """Incrementally read trace events appended after ``cursor``.
-
-    The cursor is a byte offset into the trace file, which is robust to appends
-    (the file is append-only) and makes repeated polling O(new bytes) rather than
-    O(all events). Returns ``(events, next_cursor)`` where ``next_cursor`` should
-    be passed back on the next call to fetch only newer events.
-
-    Never raises: on any error it returns an empty batch and a safe cursor. A
-    ``cursor`` past the current end-of-file (e.g. the log was rotated/truncated)
-    is treated as a reset so the caller still makes progress.
-    """
-    trace_file = project_root / ".devcouncil" / "logs" / "traces.jsonl"
-    start = cursor if isinstance(cursor, int) and cursor >= 0 else 0
-    if not trace_file.exists():
-        return [], start
-
-    try:
-        size = trace_file.stat().st_size
-        # File shrank (rotation/truncation) — restart from the beginning.
-        if start > size:
-            start = 0
-
-        with open(trace_file, "rb") as f:
-            f.seek(start)
-            chunk = f.read()
-    except Exception as exc:
-        logger.debug("Failed incremental trace read: %s", exc)
-        return [], start
-
-    # Only consume up to the last complete line so a half-written final line is
-    # re-read (not skipped) on the next poll once it is fully flushed.
-    last_newline = chunk.rfind(b"\n")
-    if last_newline == -1:
-        return [], start
-    consumed = chunk[: last_newline + 1]
-    next_cursor = start + len(consumed)
-
-    events: List[TraceEvent] = []
-    for raw_line in consumed.decode("utf-8", errors="replace").splitlines():
-        if not raw_line.strip():
-            continue
-        try:
-            events.append(TraceEvent.from_legacy(json.loads(raw_line)))
-        except Exception as exc:
-            logger.debug("Skipping invalid trace line: %s", exc)
-    return events, next_cursor

package/src/devcouncil/telemetry/tracker.py

@@ -1,52 +0,0 @@
-import json
-from pathlib import Path
-from typing import Dict, Any
-
-from devcouncil.telemetry.pricing import pricing_for_model
-
-class TelemetryTracker:
-    def __init__(self, project_root: Path):
-        self.log_file = project_root / ".devcouncil" / "logs" / "telemetry.json"
-        self.stats = self._load()
-
-    def _load(self) -> Dict[str, Any]:
-        if self.log_file.exists():
-            try:
-                with open(self.log_file, "r") as f:
-                    return json.load(f)
-            except Exception:
-                pass
-        return {"total_cost": 0.0, "total_prompt_tokens": 0, "total_completion_tokens": 0, "models": {}}
-
-    def _save(self):
-        self.log_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.log_file, "w") as f:
-            json.dump(self.stats, f, indent=2)
-
-    def log_usage(self, model: str, usage: Dict[str, int], *, local: bool = False):
-        prompt_tokens = usage.get("prompt_tokens", 0)
-        completion_tokens = usage.get("completion_tokens", 0)
-
-        if local:
-            # On-device providers (Ollama) incur no per-token cost. Zero by provider, not
-            # by model-id matching — consistent with telemetry/cost.py — so a local tag
-            # that happens to collide with a priced entry is never billed.
-            cost = 0.0
-        else:
-            rates = pricing_for_model(model)
-            cost = (prompt_tokens / 1000.0) * rates["prompt_per_1k"] + (
-                completion_tokens / 1000.0
-            ) * rates["completion_per_1k"]
-
-        self.stats["total_cost"] += cost
-        self.stats["total_prompt_tokens"] += prompt_tokens
-        self.stats["total_completion_tokens"] += completion_tokens
-
-        if model not in self.stats["models"]:
-            self.stats["models"][model] = {"cost": 0.0, "prompt_tokens": 0, "completion_tokens": 0}
-
-        self.stats["models"][model]["cost"] += cost
-        self.stats["models"][model]["prompt_tokens"] += prompt_tokens
-        self.stats["models"][model]["completion_tokens"] += completion_tokens
-
-        self._save()

package/src/devcouncil/ui/__init__.py

@@ -1 +0,0 @@
-"""Live DevCouncil dashboard helpers."""

package/src/devcouncil/ui/dashboard.py

@@ -1,423 +0,0 @@
-from __future__ import annotations
-
-import json
-import secrets
-import time
-from importlib import resources
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-from urllib.parse import urlparse
-
-from devcouncil.app.project_status import compute_phase
-from devcouncil.integrations.actions import apply_integration_target
-from devcouncil.integrations.check import build_integration_check_report, integration_status_summary
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import ArtifactGraphRepository, StateRepository, TaskRepository
-from devcouncil.telemetry.traces import read_trace_events
-
-LOGO_ASSET = "devcouncil_logo_premium.png"
-LEGACY_LOGO_ASSET = "devcouncil-logo.svg"
-
-
-# mtime-keyed cache so the dashboard's poll loop doesn't re-read and re-parse
-# every run manifest on each refresh.
-_RUN_MANIFEST_CACHE: dict[str, tuple[float, dict]] = {}
-
-
-def _load_run_manifest(manifest_path: Path) -> dict | None:
-    key = str(manifest_path)
-    try:
-        mtime = manifest_path.stat().st_mtime
-    except OSError:
-        return None
-    cached = _RUN_MANIFEST_CACHE.get(key)
-    if cached is not None and cached[0] == mtime:
-        return dict(cached[1])
-    try:
-        manifest = json.loads(manifest_path.read_text(encoding="utf-8")) or {}
-    except (json.JSONDecodeError, OSError):
-        return None
-    _RUN_MANIFEST_CACHE[key] = (mtime, manifest)
-    return dict(manifest)
-
-
-def recent_run_artifacts(project_root: Path, *, limit: int = 10) -> list[dict]:
-    runs_dir = project_root / ".devcouncil" / "runs"
-    if not runs_dir.exists():
-        return []
-    manifests: list[dict] = []
-    for manifest_path in sorted(
-        runs_dir.glob("*/agent-run.json"),
-        key=lambda path: path.stat().st_mtime,
-        reverse=True,
-    ):
-        manifest = _load_run_manifest(manifest_path)
-        if manifest is None:
-            continue
-        manifest["manifest_path"] = str(manifest_path)
-        manifests.append(manifest)
-        if len(manifests) >= limit:
-            break
-    return manifests
-
-
-# Integration status probes the filesystem (and optionally CLIs) — far too
-# expensive to recompute on every 2-second dashboard poll.
-_INTEGRATION_SUMMARY_TTL_SECONDS = 5.0
-_INTEGRATION_SUMMARY_CACHE: dict[str, tuple[float, dict]] = {}
-
-
-def _integration_summary_cached(project_root: Path) -> dict:
-    key = str(project_root)
-    now = time.monotonic()
-    cached = _INTEGRATION_SUMMARY_CACHE.get(key)
-    if cached is not None and now - cached[0] < _INTEGRATION_SUMMARY_TTL_SECONDS:
-        return cached[1]
-    summary = integration_status_summary(project_root)
-    _INTEGRATION_SUMMARY_CACHE[key] = (now, summary)
-    return summary
-
-
-def _invalidate_integration_summary(project_root: Path) -> None:
-    _INTEGRATION_SUMMARY_CACHE.pop(str(project_root), None)
-
-
-def logo_svg() -> str:
-    return resources.files("devcouncil.assets").joinpath(LEGACY_LOGO_ASSET).read_text(encoding="utf-8")
-
-
-def logo_asset_bytes() -> bytes:
-    return resources.files("devcouncil.assets").joinpath(LOGO_ASSET).read_bytes()
-
-
-def dashboard_payload(project_root: Path) -> dict:
-    db = get_db(project_root)
-    if not db:
-        return {
-            "initialized": False,
-            "phase": "UNINITIALIZED",
-            "tasks": [],
-            "coverage": {},
-            "events": [],
-            "integrations": _integration_summary_cached(project_root),
-            "recent_runs": recent_run_artifacts(project_root),
-        }
-    with db.get_session() as session:
-        graph = ArtifactGraphRepository(session).load_graph()
-        state = StateRepository(session).get_state()
-        phase = compute_phase(graph, state.current_phase if state else None)
-        tasks = [task.model_dump() for task in TaskRepository(session).get_all()]
-        return {
-            "initialized": True,
-            "phase": phase,
-            "coverage": graph.coverage_summary(),
-            "tasks": tasks,
-            "events": [event.model_dump(by_alias=True) for event in list(read_trace_events(project_root))[-50:]],
-            "integrations": _integration_summary_cached(project_root),
-            "recent_runs": recent_run_artifacts(project_root),
-        }
-
-
-def _json_response(handler: BaseHTTPRequestHandler, status: int, payload: dict) -> None:
-    body = json.dumps(payload).encode("utf-8")
-    handler.send_response(status)
-    handler.send_header("Content-Type", "application/json")
-    handler.send_header("Content-Length", str(len(body)))
-    handler.end_headers()
-    handler.wfile.write(body)
-
-
-def _is_loopback_client(handler: BaseHTTPRequestHandler) -> bool:
-    host = handler.client_address[0] if handler.client_address else ""
-    return host in {"127.0.0.1", "::1", "localhost"}
-
-
-def dashboard_apply_payload(
-    project_root: Path,
-    raw_body: bytes,
-    *,
-    token: str,
-    provided_token: str | None,
-) -> dict:
-    if not token or provided_token != token:
-        return {"ok": False, "error": "invalid dashboard token"}
-    try:
-        request = json.loads(raw_body.decode("utf-8") or "{}")
-    except json.JSONDecodeError:
-        return {"ok": False, "error": "invalid JSON body"}
-    if not isinstance(request, dict):
-        return {"ok": False, "error": "request body must be a JSON object"}
-    target = str(request.get("target") or "").strip()
-    include_hooks = bool(request.get("include_hooks", True))
-    strict = bool(request.get("strict", False))
-    try:
-        report = apply_integration_target(
-            project_root,
-            target,
-            include_hooks=include_hooks,
-            strict=strict,
-        )
-    except ValueError as exc:
-        return {"ok": False, "error": str(exc)}
-    # The next poll should reflect the freshly applied integration.
-    _invalidate_integration_summary(project_root)
-    return report.as_dict()
-
-
-def dashboard_html(token: str = "") -> str:
-    safe_token = token.replace('"', "")
-    return f"""<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="devcouncil-dashboard-token" content="{safe_token}">
-  <title>DevCouncil Dashboard</title>
-  <style>
-    body {{ margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f7f7f5; color: #202124; }}
-    header {{ padding: 18px 28px; border-bottom: 1px solid #d9d9d4; background: #ffffff; display: flex; align-items: center; justify-content: space-between; gap: 18px; }}
-    main {{ padding: 24px 28px; display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }}
-    section {{ background: #ffffff; border: 1px solid #d9d9d4; border-radius: 8px; padding: 16px; }}
-    h1 {{ font-size: 20px; margin: 0; }}
-    h2 {{ font-size: 15px; margin: 0 0 12px; }}
-    .brand {{ display: flex; align-items: center; gap: 12px; min-width: 0; }}
-    .brand img {{ width: 54px; height: 54px; flex: 0 0 auto; filter: drop-shadow(0 8px 12px rgba(12, 36, 52, 0.22)); }}
-    .phase-line {{ white-space: nowrap; }}
-    .phase {{ font-weight: 700; }}
-    table {{ width: 100%; border-collapse: collapse; font-size: 13px; }}
-    th, td {{ text-align: left; border-bottom: 1px solid #ededeb; padding: 8px; vertical-align: top; }}
-    pre {{ margin: 0; white-space: pre-wrap; font-size: 12px; }}
-    .toolbar {{ display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 12px; }}
-    button {{ border: 1px solid #b9b9b2; background: #ffffff; color: #202124; border-radius: 6px; padding: 6px 10px; font: inherit; cursor: pointer; }}
-    button:disabled {{ color: #898984; cursor: default; background: #f3f3f0; }}
-    .status-pill {{ display: inline-block; min-width: 58px; padding: 2px 6px; border-radius: 999px; font-size: 12px; text-align: center; background: #ededeb; }}
-    .status-ok {{ background: #dff3e4; color: #155724; }}
-    .status-warn {{ background: #fff3cd; color: #664d03; }}
-    .status-fail {{ background: #f8d7da; color: #842029; }}
-    #integration-result {{ margin-top: 10px; font-size: 12px; }}
-    @media (max-width: 800px) {{ main {{ grid-template-columns: 1fr; padding: 16px; }} header {{ padding: 16px; }} }}
-  </style>
-</head>
-<body>
-  <header><div class="brand"><img src="/assets/devcouncil_logo_premium.png" alt="DevCouncil logo"><h1>DevCouncil Dashboard</h1></div><div class="phase-line">Phase: <span id="phase" class="phase">loading</span></div></header>
-  <main>
-    <section><h2>Coverage</h2><pre id="coverage">{{}}</pre></section>
-    <section><h2>Tasks</h2><table><thead><tr><th>ID</th><th>Status</th><th>Title</th></tr></thead><tbody id="tasks"></tbody></table></section>
-    <section style="grid-column: 1 / -1;">
-      <h2>CLI Integrations</h2>
-      <div class="toolbar">
-        <button type="button" data-target="all">Apply Detected</button>
-        <button type="button" data-target="hooks">Install Hooks</button>
-        <button type="button" id="run-check">Run Check</button>
-      </div>
-      <pre id="integration-result"></pre>
-      <table>
-        <thead><tr><th>Client</th><th>PATH</th><th>MCP</th><th>Hooks</th><th>Launcher</th><th>Configured</th><th>Notes</th><th>Action</th></tr></thead>
-        <tbody id="integrations"></tbody>
-      </table>
-    </section>
-    <section style="grid-column: 1 / -1;">
-      <h2>Recent Agent Runs</h2>
-      <table>
-        <thead><tr><th>Run</th><th>Task</th><th>Agent</th><th>Status</th><th>Transcript</th></tr></thead>
-        <tbody id="runs"></tbody>
-      </table>
-    </section>
-    <section style="grid-column: 1 / -1;"><h2>Recent Trace Events</h2><pre id="events"></pre></section>
-  </main>
-  <script>
-    function setText(cell, value) {{
-      cell.textContent = value == null ? '' : String(value);
-      return cell;
-    }}
-
-    function statusClass(value) {{
-      if (value === 'ok') return 'status-pill status-ok';
-      if (value === 'missing' || value === 'drifted') return 'status-pill status-warn';
-      return 'status-pill';
-    }}
-
-    function statusCell(value) {{
-      const cell = document.createElement('td');
-      const pill = document.createElement('span');
-      pill.className = statusClass(value);
-      pill.textContent = value || 'n/a';
-      cell.appendChild(pill);
-      return cell;
-    }}
-
-    const token = document.querySelector('meta[name="devcouncil-dashboard-token"]').content;
-
-    async function applyIntegration(target) {{
-      const resultBox = document.getElementById('integration-result');
-      resultBox.textContent = `Running ${{target}}...`;
-      const res = await fetch('/api/integrations/apply', {{
-        method: 'POST',
-        headers: {{
-          'Content-Type': 'application/json',
-          'X-DevCouncil-Dashboard-Token': token,
-        }},
-        body: JSON.stringify({{ target }}),
-      }});
-      const payload = await res.json();
-      resultBox.textContent = JSON.stringify(payload, null, 2);
-      await refresh();
-    }}
-
-    async function runIntegrationCheck() {{
-      const resultBox = document.getElementById('integration-result');
-      const res = await fetch('/api/integrations/check');
-      const payload = await res.json();
-      resultBox.textContent = JSON.stringify(payload, null, 2);
-    }}
-
-    async function refresh() {{
-      const res = await fetch('/api/status');
-      const data = await res.json();
-      document.getElementById('phase').textContent = data.phase;
-      document.getElementById('coverage').textContent = JSON.stringify(data.coverage, null, 2);
-      const body = document.getElementById('tasks');
-      body.replaceChildren(...(data.tasks || []).map(t => {{
-        const row = document.createElement('tr');
-        row.appendChild(setText(document.createElement('td'), t.id));
-        row.appendChild(setText(document.createElement('td'), t.status));
-        row.appendChild(setText(document.createElement('td'), t.title));
-        return row;
-      }}));
-      const integrationsBody = document.getElementById('integrations');
-      const capabilities = ((data.integrations || {{}}).capabilities || []);
-      integrationsBody.replaceChildren(...capabilities.map(item => {{
-        const row = document.createElement('tr');
-        row.appendChild(setText(document.createElement('td'), item.label || item.name));
-        row.appendChild(setText(document.createElement('td'), item.on_path ? 'yes' : 'no'));
-        row.appendChild(setText(document.createElement('td'), item.mcp ? 'yes' : 'no'));
-        row.appendChild(setText(document.createElement('td'), item.hooks ? 'yes' : 'verification'));
-        row.appendChild(setText(document.createElement('td'), item.launcher_shim ? 'yes' : 'no'));
-        row.appendChild(statusCell(item.config_status));
-        row.appendChild(setText(document.createElement('td'), item.notes || ''));
-        const action = document.createElement('td');
-        const button = document.createElement('button');
-        button.type = 'button';
-        button.dataset.target = item.apply_target || item.name;
-        button.textContent = item.config_status === 'ok' ? 'Reapply' : 'Fix';
-        button.disabled = !item.fixable;
-        action.appendChild(button);
-        row.appendChild(action);
-        return row;
-      }}));
-
-      const runsBody = document.getElementById('runs');
-      runsBody.replaceChildren(...(data.recent_runs || []).map(run => {{
-        const row = document.createElement('tr');
-        row.appendChild(setText(document.createElement('td'), run.run_id));
-        row.appendChild(setText(document.createElement('td'), run.task_id));
-        row.appendChild(setText(document.createElement('td'), run.agent));
-        row.appendChild(setText(document.createElement('td'), run.status || 'unknown'));
-        row.appendChild(setText(document.createElement('td'), run.transcript || ''));
-        return row;
-      }}));
-
-      document.getElementById('events').textContent = JSON.stringify(data.events || [], null, 2);
-    }}
-
-    document.addEventListener('click', event => {{
-      const button = event.target;
-      if (!(button instanceof HTMLButtonElement)) return;
-      if (button.id === 'run-check') {{
-        runIntegrationCheck();
-        return;
-      }}
-      const target = button.dataset.target;
-      if (target) applyIntegration(target);
-    }});
-
-    refresh();
-    setInterval(refresh, 2000);
-  </script>
-</body>
-</html>"""
-
-
-def run_dashboard(project_root: Path, host: str = "127.0.0.1", port: int = 8765) -> None:
-    dashboard_token = secrets.token_urlsafe(24)
-
-    class DashboardServer(ThreadingHTTPServer):
-        allow_reuse_address = True
-        daemon_threads = True
-
-    class Handler(BaseHTTPRequestHandler):
-        def do_GET(self):  # noqa: N802
-            parsed = urlparse(self.path)
-            if parsed.path == f"/assets/{LOGO_ASSET}":
-                body = logo_asset_bytes()
-                self.send_response(200)
-                self.send_header("Content-Type", "image/png")
-                self.send_header("Cache-Control", "public, max-age=3600")
-                self.send_header("Content-Length", str(len(body)))
-                self.end_headers()
-                self.wfile.write(body)
-                return
-            if parsed.path == f"/assets/{LEGACY_LOGO_ASSET}":
-                body = logo_svg().encode("utf-8")
-                self.send_response(200)
-                self.send_header("Content-Type", "image/svg+xml; charset=utf-8")
-                self.send_header("Cache-Control", "public, max-age=3600")
-                self.send_header("Content-Length", str(len(body)))
-                self.end_headers()
-                self.wfile.write(body)
-                return
-            if parsed.path == "/api/integrations/check":
-                body = json.dumps(build_integration_check_report(project_root).as_dict()).encode("utf-8")
-                self.send_response(200)
-                self.send_header("Content-Type", "application/json")
-                self.send_header("Content-Length", str(len(body)))
-                self.end_headers()
-                self.wfile.write(body)
-                return
-            if parsed.path == "/api/status":
-                body = json.dumps(dashboard_payload(project_root)).encode("utf-8")
-                self.send_response(200)
-                self.send_header("Content-Type", "application/json")
-                self.send_header("Content-Length", str(len(body)))
-                self.end_headers()
-                self.wfile.write(body)
-                return
-            if parsed.path.startswith("/api/"):
-                body = json.dumps({"error": "Not found"}).encode("utf-8")
-                self.send_response(404)
-                self.send_header("Content-Type", "application/json")
-                self.send_header("Content-Length", str(len(body)))
-                self.end_headers()
-                self.wfile.write(body)
-                return
-            body = dashboard_html(dashboard_token).encode("utf-8")
-            self.send_response(200)
-            self.send_header("Content-Type", "text/html; charset=utf-8")
-            self.send_header("Content-Length", str(len(body)))
-            self.end_headers()
-            self.wfile.write(body)
-
-        def do_POST(self):  # noqa: N802
-            parsed = urlparse(self.path)
-            if parsed.path != "/api/integrations/apply":
-                _json_response(self, 404, {"ok": False, "error": "Not found"})
-                return
-            if not _is_loopback_client(self):
-                _json_response(self, 403, {"ok": False, "error": "dashboard mutations require loopback client"})
-                return
-            length = int(self.headers.get("Content-Length") or "0")
-            raw_body = self.rfile.read(length)
-            provided = self.headers.get("X-DevCouncil-Dashboard-Token")
-            payload = dashboard_apply_payload(
-                project_root,
-                raw_body,
-                token=dashboard_token,
-                provided_token=provided,
-            )
-            _json_response(self, 200 if payload.get("ok") else 403, payload)
-
-        def log_message(self, format, *args):  # noqa: A002
-            return
-
-    server = DashboardServer((host, port), Handler)
-    server.serve_forever()

package/src/devcouncil/utils/__init__.py

@@ -1 +0,0 @@
-"""Utilities package: redaction, paths, hashing, subprocess helpers."""