ci: add release hardening quality gates

Author: QUSETIONS

.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    name: Python ${{ matrix.python-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.11", "3.12"]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package
+        run: python -m pip install -e ".[dev]"
+
+      - name: Compile sources
+        run: python -m compileall -q minicode tests
+
+      - name: Run packaging smoke tests
+        run: python -m pytest tests/test_packaging.py -q
+
+      - name: Run test suite
+        run: python -m pytest -q

conftest.py

@@ -0,0 +1,20 @@
+"""Pytest collection controls for repository-local legacy smoke scripts."""
+
+from __future__ import annotations
+
+
+# These root-level scripts are manual smoke/integration utilities from earlier
+# development rounds. Normal pytest coverage lives under tests/.
+collect_ignore = [
+    "smoke_test.py",
+    "test_chinese_input.py",
+    "test_integration.py",
+    "test_optim.py",
+    "test_run.py",
+    "test_state_integration.py",
+    "visual_test.py",
+]
+
+collect_ignore_glob = [
+    "benchmarks/*.py",
+]

minicode/cron_runner.py

@@ -0,0 +1,82 @@
+"""Scheduled headless task runner for MiniCode.
+
+Config format:
+
+{
+  "tasks": [
+    {"name": "daily-check", "prompt": "Summarize the repository status"}
+  ]
+}
+
+Without a config file, the runner exits cleanly with an explanatory message.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+
+def _default_config_path() -> Path:
+    return Path(os.environ.get("MINI_CODE_CRON_CONFIG", ".mini-code/cron.json"))
+
+
+def load_cron_config(path: str | Path | None = None) -> dict[str, Any]:
+    config_path = Path(path) if path is not None else _default_config_path()
+    if not config_path.exists():
+        return {"tasks": []}
+    data = json.loads(config_path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("cron config must be a JSON object")
+    tasks = data.get("tasks", [])
+    if not isinstance(tasks, list):
+        raise ValueError("cron config field 'tasks' must be a list")
+    return {"tasks": tasks}
+
+
+def run_configured_tasks(config: dict[str, Any], *, dry_run: bool = False) -> list[dict[str, Any]]:
+    from minicode.headless import run_headless
+
+    results: list[dict[str, Any]] = []
+    for index, task in enumerate(config.get("tasks", [])):
+        if not isinstance(task, dict):
+            results.append({"index": index, "ok": False, "error": "task must be an object"})
+            continue
+        prompt = str(task.get("prompt", "")).strip()
+        name = str(task.get("name") or f"task-{index + 1}")
+        if not prompt:
+            results.append({"name": name, "ok": False, "error": "prompt is required"})
+            continue
+        if dry_run:
+            results.append({"name": name, "ok": True, "dryRun": True})
+            continue
+        results.append({"name": name, "ok": True, "response": run_headless(prompt)})
+    return results
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Run MiniCode scheduled headless tasks.")
+    parser.add_argument("--config", default=None, help="Path to cron JSON config.")
+    parser.add_argument("--once", action="store_true", help="Run tasks once and exit.")
+    parser.add_argument("--dry-run", action="store_true", help="Validate tasks without executing prompts.")
+    parser.add_argument("--interval", type=float, default=60.0, help="Polling interval in seconds.")
+    args = parser.parse_args(argv)
+
+    while True:
+        config = load_cron_config(args.config)
+        if not config["tasks"]:
+            print(f"No cron tasks configured in {args.config or _default_config_path()}.", flush=True)
+        else:
+            for result in run_configured_tasks(config, dry_run=args.dry_run):
+                print(json.dumps(result, ensure_ascii=False), flush=True)
+        if args.once or not config["tasks"]:
+            return
+        time.sleep(max(args.interval, 1.0))
+
+
+if __name__ == "__main__":
+    main()

minicode/gateway.py

@@ -0,0 +1,76 @@
+"""Minimal HTTP gateway for MiniCode.
+
+The gateway intentionally uses only the standard library so the Docker and
+console entry points remain zero-dependency. It exposes a health endpoint and a
+small headless execution endpoint for platform bridges to build on.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+
+
+def _json_bytes(payload: dict[str, Any], status: int = 200) -> tuple[int, bytes]:
+    return status, json.dumps(payload, ensure_ascii=False).encode("utf-8")
+
+
+class MiniCodeGatewayHandler(BaseHTTPRequestHandler):
+    server_version = "MiniCodeGateway/0.1"
+
+    def log_message(self, format: str, *args: Any) -> None:  # noqa: A002
+        if os.environ.get("MINI_CODE_GATEWAY_ACCESS_LOG") == "1":
+            super().log_message(format, *args)
+
+    def _send_json(self, payload: dict[str, Any], status: int = 200) -> None:
+        status_code, body = _json_bytes(payload, status)
+        self.send_response(status_code)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:  # noqa: N802
+        if self.path in {"/", "/health"}:
+            self._send_json({"ok": True, "service": "minicode-gateway"})
+            return
+        self._send_json({"ok": False, "error": "not found"}, status=404)
+
+    def do_POST(self) -> None:  # noqa: N802
+        if self.path != "/run":
+            self._send_json({"ok": False, "error": "not found"}, status=404)
+            return
+
+        try:
+            length = int(self.headers.get("Content-Length", "0"))
+            raw = self.rfile.read(length).decode("utf-8")
+            data = json.loads(raw) if raw.strip() else {}
+            prompt = str(data.get("prompt", "")).strip()
+            if not prompt:
+                self._send_json({"ok": False, "error": "prompt is required"}, status=400)
+                return
+
+            from minicode.headless import run_headless
+
+            self._send_json({"ok": True, "response": run_headless(prompt)})
+        except Exception as exc:  # noqa: BLE001
+            self._send_json({"ok": False, "error": str(exc)}, status=500)
+
+
+def run_gateway() -> None:
+    host = os.environ.get("MINI_CODE_GATEWAY_HOST", "127.0.0.1")
+    port = int(os.environ.get("MINI_CODE_GATEWAY_PORT", "8080"))
+    server = ThreadingHTTPServer((host, port), MiniCodeGatewayHandler)
+    print(f"MiniCode gateway listening on http://{host}:{port}", flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+
+
+if __name__ == "__main__":
+    run_gateway()

tests/test_packaging.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import importlib
+import json
+import subprocess
+import sys
+import threading
+import tomllib
+import urllib.request
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent
+
+
+def test_console_script_entry_points_import() -> None:
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+
+    failures = []
+    for name, target in pyproject["project"]["scripts"].items():
+        module_name, _, attr_name = target.partition(":")
+        try:
+            module = importlib.import_module(module_name)
+        except Exception as exc:  # noqa: BLE001
+            failures.append(f"{name}: cannot import {module_name}: {exc}")
+            continue
+        if not hasattr(module, attr_name):
+            failures.append(f"{name}: {module_name}.{attr_name} does not exist")
+
+    assert failures == []
+
+
+def test_legacy_root_smoke_scripts_are_not_pytest_collected() -> None:
+    import conftest
+
+    root_smoke_scripts = {
+        path.name
+        for pattern in ("test_*.py", "*_test.py")
+        for path in ROOT.glob(pattern)
+    }
+
+    assert root_smoke_scripts
+    assert root_smoke_scripts.issubset(set(conftest.collect_ignore))
+    assert "benchmarks/*.py" in conftest.collect_ignore_glob
+
+
+def test_ci_workflow_runs_release_quality_gates() -> None:
+    workflow = ROOT / ".github" / "workflows" / "ci.yml"
+
+    assert workflow.exists()
+    content = workflow.read_text(encoding="utf-8")
+    assert "python -m compileall -q minicode tests" in content
+    assert "python -m pytest -q" in content
+    assert "tests/test_packaging.py" in content
+
+
+def test_cron_runner_empty_config_exits_cleanly(tmp_path: Path) -> None:
+    missing_config = tmp_path / "missing-cron.json"
+
+    completed = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "minicode.cron_runner",
+            "--once",
+            "--dry-run",
+            "--config",
+            str(missing_config),
+        ],
+        cwd=ROOT,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        timeout=20,
+        check=False,
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    assert "No cron tasks configured" in completed.stdout
+
+
+def test_gateway_health_endpoint_responds() -> None:
+    from http.server import ThreadingHTTPServer
+
+    from minicode.gateway import MiniCodeGatewayHandler
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), MiniCodeGatewayHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        port = server.server_address[1]
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=5) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+        assert payload == {"ok": True, "service": "minicode-gateway"}
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)