Integration-Automation
diff --git a/‎.github/workflows/docker.yml‎
Lines changed: 92 additions & 0 deletions b/‎.github/workflows/docker.yml‎
Lines changed: 92 additions & 0 deletions
diff --git a/‎autocontrol-lsp/autocontrol_lsp/server/diagnostics.py‎
Lines changed: 106 additions & 0 deletions b/‎autocontrol-lsp/autocontrol_lsp/server/diagnostics.py‎
Lines changed: 106 additions & 0 deletions
diff --git a/‎autocontrol-lsp/autocontrol_lsp/server/documents.py‎
Lines changed: 152 additions & 0 deletions b/‎autocontrol-lsp/autocontrol_lsp/server/documents.py‎
Lines changed: 152 additions & 0 deletions
@@ -0,0 +1,92 @@
+name: AutoControl Docker CI
+
+on:
+  push:
+    branches: [ "dev", "main" ]
+    paths:
+      - "docker/**"
+      - "je_auto_control/**"
+      - "pyproject.toml"
+      - ".github/workflows/docker.yml"
+  pull_request:
+    branches: [ "dev", "main" ]
+    paths:
+      - "docker/**"
+      - "je_auto_control/**"
+      - "pyproject.toml"
+      - ".github/workflows/docker.yml"
+
+permissions:
+  contents: read
+
+jobs:
+  build-image:
+    name: Build AutoControl container
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build image (no push)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/Dockerfile
+          tags: autocontrol:ci
+          load: true
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Image size
+        run: docker image inspect autocontrol:ci --format='size={{.Size}} bytes'
+
+  headless-tests:
+    name: Headless pytest inside the image
+    needs: build-image
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Rebuild image (cached)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/Dockerfile
+          tags: autocontrol:ci
+          load: true
+          cache-from: type=gha
+
+      # Mount the repo so pytest can read tests + write the artifact.
+      - name: Run headless tests under Xvfb
+        run: |
+          docker run --rm \
+            --user root \
+            -v "$PWD:/work" -w /work \
+            --entrypoint /bin/sh \
+            autocontrol:ci -c "
+              pip install --no-cache-dir -r dev_requirements.txt &&
+              xvfb-run -a -s '-screen 0 1280x800x24' \
+                python -m pytest test/unit_test/headless -q --tb=short
+            "
+
+      - name: Smoke test the entrypoint (rest mode)
+        run: |
+          docker run --rm -d --name ac-rest -p 9939:9939 \
+            -e AC_TOKEN=ci-token autocontrol:ci rest
+          for attempt in 1 2 3 4 5 6 7 8 9 10; do
+            if curl -fsS -H "Authorization: Bearer ci-token" \
+                http://127.0.0.1:9939/health; then
+              echo "REST API is up"
+              break
+            fi
+            sleep 2
+          done
+          docker logs ac-rest || true
+          docker stop ac-rest
@@ -0,0 +1,106 @@
+"""Build LSP ``Diagnostic`` lists for an AutoControl action JSON file.
+
+Two layers of checking:
+
+1. **JSON parse**: a parse failure surfaces as a diagnostic at the
+   reported error line, with severity ``Error``;
+2. **Schema**: top-level must be a list; each entry must be a 1- or
+   2-element list ``[name]`` / ``[name, params_dict]`` where ``name``
+   is a registered ``AC_*`` command and ``params`` is an object.
+
+Diagnostics are returned in the LSP wire shape — the server hands
+them straight to ``textDocument/publishDiagnostics``.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from autocontrol_lsp.server.commands import known_action_names
+
+
+_SEVERITY_ERROR = 1
+_SEVERITY_WARNING = 2
+
+
+def diagnostics_for(text: str) -> List[Dict[str, Any]]:
+    """Return every problem found in ``text`` as an LSP Diagnostic dict."""
+    try:
+        data = json.loads(text or "")
+    except json.JSONDecodeError as error:
+        return [_parse_error_diagnostic(error)]
+    return _schema_diagnostics(data)
+
+
+def _parse_error_diagnostic(error: json.JSONDecodeError) -> Dict[str, Any]:
+    line = max(0, int(error.lineno) - 1)
+    column = max(0, int(error.colno) - 1)
+    return {
+        "range": {
+            "start": {"line": line, "character": column},
+            "end": {"line": line, "character": column + 1},
+        },
+        "severity": _SEVERITY_ERROR,
+        "source": "autocontrol-lsp",
+        "message": f"invalid JSON: {error.msg}",
+    }
+
+
+def _schema_diagnostics(data: Any) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    if not isinstance(data, list):
+        out.append(_root_must_be_list_diagnostic())
+        return out
+    known = set(known_action_names())
+    for index, entry in enumerate(data):
+        problem = _check_entry(entry, known)
+        if problem is None:
+            continue
+        out.append(_diagnostic_for_entry(index, problem))
+    return out
+
+
+def _check_entry(entry: Any, known: set) -> Optional[str]:
+    if not isinstance(entry, list):
+        return "action must be a list of [name] or [name, params]"
+    if not entry:
+        return "action list cannot be empty"
+    name = entry[0]
+    if not isinstance(name, str):
+        return f"action name must be a string, got {type(name).__name__}"
+    if not name.startswith("AC_"):
+        return f"action name {name!r} must start with AC_"
+    if name not in known:
+        return f"unknown AC_ command: {name!r}"
+    if len(entry) > 2:
+        return "action accepts at most [name, params]"
+    if len(entry) == 2 and not isinstance(entry[1], dict):
+        return "params must be an object"
+    return None
+
+
+def _diagnostic_for_entry(index: int, message: str) -> Dict[str, Any]:
+    return {
+        "range": {
+            "start": {"line": 0, "character": 0},
+            "end": {"line": 0, "character": 1},
+        },
+        "severity": _SEVERITY_WARNING,
+        "source": "autocontrol-lsp",
+        "message": f"action[{index}]: {message}",
+    }
+
+
+def _root_must_be_list_diagnostic() -> Dict[str, Any]:
+    return {
+        "range": {
+            "start": {"line": 0, "character": 0},
+            "end": {"line": 0, "character": 1},
+        },
+        "severity": _SEVERITY_ERROR,
+        "source": "autocontrol-lsp",
+        "message": "action file must be a JSON list of [name, params] entries",
+    }
+
+
+__all__ = ["diagnostics_for"]
@@ -0,0 +1,152 @@
+"""In-memory document store for the LSP server.
+
+LSP clients send ``textDocument/didOpen`` with the full file contents
+and ``didChange`` with either full or incremental updates. The server
+needs the *current* text whenever hover / completion / diagnostics is
+requested — that's what this module owns. Pure stdlib, thread-safe.
+"""
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence
+
+
+@dataclass(frozen=True)
+class Position:
+    """Zero-based ``(line, character)`` LSP position."""
+
+    line: int
+    character: int
+
+
+@dataclass(frozen=True)
+class TextDocument:
+    """Versioned text snapshot keyed by URI."""
+
+    uri: str
+    text: str
+    version: int = 0
+
+    def lines(self) -> List[str]:
+        return self.text.splitlines()
+
+    def word_at(self, position: Position) -> str:
+        """Return the identifier-like word under ``position`` (LSP style)."""
+        rows = self.lines()
+        if position.line < 0 or position.line >= len(rows):
+            return ""
+        line = rows[position.line]
+        index = position.character
+        if index < 0 or index > len(line):
+            return ""
+        return _word_around(line, min(index, len(line)))
+
+
+class DocumentStore:
+    """Thread-safe ``uri → TextDocument`` map for the LSP loop."""
+
+    def __init__(self) -> None:
+        self._docs: Dict[str, TextDocument] = {}
+        self._lock = threading.RLock()
+
+    def open(self, uri: str, text: str, version: int = 0) -> TextDocument:
+        doc = TextDocument(uri=str(uri), text=str(text), version=int(version))
+        with self._lock:
+            self._docs[doc.uri] = doc
+        return doc
+
+    def replace(self, uri: str, text: str,
+                 version: Optional[int] = None) -> TextDocument:
+        with self._lock:
+            existing = self._docs.get(uri)
+        next_version = (
+            int(version) if version is not None
+            else (existing.version + 1 if existing else 0)
+        )
+        return self.open(uri, text, next_version)
+
+    def close(self, uri: str) -> bool:
+        with self._lock:
+            return self._docs.pop(uri, None) is not None
+
+    def get(self, uri: str) -> Optional[TextDocument]:
+        with self._lock:
+            return self._docs.get(uri)
+
+    def count(self) -> int:
+        with self._lock:
+            return len(self._docs)
+
+    def apply_change(self, uri: str,
+                     changes: Sequence[Dict],
+                     version: Optional[int] = None,
+                     ) -> Optional[TextDocument]:
+        """Apply LSP ``contentChanges`` entries to the stored document.
+
+        Supports both full-document and range-incremental forms.
+        Returns the updated document, or None when the URI isn't tracked.
+        """
+        with self._lock:
+            doc = self._docs.get(uri)
+        if doc is None:
+            return None
+        text = doc.text
+        for change in changes:
+            if "range" not in change:
+                text = str(change.get("text", ""))
+                continue
+            text = _apply_range_edit(text, change["range"],
+                                       str(change.get("text", "")))
+        return self.replace(uri, text, version=version)
+
+
+# --- helpers -------------------------------------------------
+
+_WORD_CHARS = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")
+
+
+def _word_around(line: str, index: int) -> str:
+    if index >= len(line):
+        index = len(line) - 1
+    if index < 0:
+        return ""
+    if line[index] not in _WORD_CHARS:
+        # Try the character to the left — common when cursor sits after a name.
+        if index > 0 and line[index - 1] in _WORD_CHARS:
+            index -= 1
+        else:
+            return ""
+    start = index
+    while start > 0 and line[start - 1] in _WORD_CHARS:
+        start -= 1
+    end = index
+    while end + 1 < len(line) and line[end + 1] in _WORD_CHARS:
+        end += 1
+    return line[start:end + 1]
+
+
+def _apply_range_edit(text: str, lsp_range: Dict,
+                       new_text: str) -> str:
+    start = lsp_range.get("start") or {}
+    end = lsp_range.get("end") or {}
+    start_index = _offset_for(text, int(start.get("line", 0)),
+                              int(start.get("character", 0)))
+    end_index = _offset_for(text, int(end.get("line", 0)),
+                            int(end.get("character", 0)))
+    if start_index > end_index:
+        start_index, end_index = end_index, start_index
+    return text[:start_index] + new_text + text[end_index:]
+
+
+def _offset_for(text: str, line: int, char: int) -> int:
+    current_line = 0
+    for index, ch in enumerate(text):
+        if current_line == line:
+            return min(len(text), index + char)
+        if ch == "\n":
+            current_line += 1
+    return len(text)
+
+
+__all__ = ["DocumentStore", "Position", "TextDocument"]