@blxzer/pactile 0.5.0

package/dist/templates/pactile/scripts/common/pactile_config.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+Standalone reader for .pactile/config.yaml.
+
+Mirrors a minimal subset of common.config so callers (hooks, workflow_phase)
+can read configuration without importing the full task/repo helpers. Returns
+an empty dict on missing/malformed files so callers stay simple.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+
+CONFIG_REL_PATH = ".pactile/config.yaml"
+
+
+def _unquote(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ('"', "'"):
+        return value[1:-1]
+    return value
+
+
+def _strip_inline_comment(value: str) -> str:
+    """Strip ` # …` inline comments while preserving `#` inside quoted strings.
+
+    YAML treats ` #` (space-hash) as a comment opener; bare `#` inside a token
+    is part of the value. Quoted strings are immune.
+    """
+    in_quote: str | None = None
+    for idx, ch in enumerate(value):
+        if in_quote:
+            if ch == in_quote:
+                in_quote = None
+            continue
+        if ch in ('"', "'"):
+            in_quote = ch
+            continue
+        if ch == "#" and (idx == 0 or value[idx - 1].isspace()):
+            return value[:idx]
+    return value
+
+
+def _next_content_line(lines: list[str], start: int) -> tuple[int, str]:
+    i = start
+    while i < len(lines):
+        stripped = lines[i].strip()
+        if stripped and not stripped.startswith("#"):
+            return i, lines[i]
+        i += 1
+    return i, ""
+
+
+def _parse_yaml_block(
+    lines: list[str], start: int, min_indent: int, target: dict
+) -> int:
+    i = start
+    current_list: list | None = None
+
+    while i < len(lines):
+        line = lines[i]
+        stripped = line.strip()
+
+        if not stripped or stripped.startswith("#"):
+            i += 1
+            continue
+
+        indent = len(line) - len(line.lstrip())
+        if indent < min_indent:
+            break
+
+        if stripped.startswith("- "):
+            if current_list is not None:
+                current_list.append(_unquote(stripped[2:].strip()))
+            i += 1
+        elif ":" in stripped:
+            key, _, value = stripped.partition(":")
+            key = key.strip()
+            value = _strip_inline_comment(value).strip()
+            value = _unquote(value)
+            current_list = None
+
+            if value:
+                target[key] = value
+                i += 1
+            else:
+                next_i, next_line = _next_content_line(lines, i + 1)
+                if next_i >= len(lines):
+                    target[key] = {}
+                    i = next_i
+                elif next_line.strip().startswith("- "):
+                    current_list = []
+                    target[key] = current_list
+                    i += 1
+                else:
+                    next_indent = len(next_line) - len(next_line.lstrip())
+                    if next_indent > indent:
+                        nested: dict = {}
+                        target[key] = nested
+                        i = _parse_yaml_block(lines, i + 1, next_indent, nested)
+                    else:
+                        target[key] = {}
+                        i += 1
+        else:
+            i += 1
+
+    return i
+
+
+def parse_simple_yaml(content: str) -> dict:
+    """Parse a small subset of YAML. See common.config for full doc."""
+    lines = content.splitlines()
+    result: dict = {}
+    _parse_yaml_block(lines, 0, 0, result)
+    return result
+
+
+def read_pactile_config(repo_root: Optional[Path] = None) -> dict:
+    """Read .pactile/config.yaml. Returns {} on missing or malformed file."""
+    root = repo_root or Path.cwd()
+    config_file = root / CONFIG_REL_PATH
+    try:
+        content = config_file.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        return {}
+    try:
+        parsed = parse_simple_yaml(content)
+    except Exception:
+        return {}
+    return parsed if isinstance(parsed, dict) else {}

package/dist/templates/pactile/scripts/common/parallel_declaration.py

@@ -0,0 +1,369 @@
+"""Planning-declaration Check helper (P38).
+
+Full / Parent planning must declare isolatable groups XOR a serial_reason.
+Check workers call ``evaluate_parallel_declaration``. This is not a
+``start-execution --check`` hard gate and not a scheduler.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from .full_quality import rigor_from_required_controls
+from .task_map import load_task_map
+
+PARALLEL_DECLARATION_SOURCE = "parallel-declaration-check"
+PARALLEL_DECLARATION_SCHEMA_VERSION = 1
+
+SERIAL_REASONS = (
+    "shared write-set",
+    "HITL or reviewer gate",
+    "depends_on unmet",
+    "user asked serial",
+    "conflict surface cannot isolate",
+)
+LITE_SERIAL_REASON = "single write-set"
+
+_SERIAL_ALIASES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    (
+        "shared write-set",
+        ("shared write-set", "shared write set", "共享写集"),
+    ),
+    (
+        "HITL or reviewer gate",
+        ("hitl or reviewer gate", "hitl", "reviewer gate", "reviewer", "门禁"),
+    ),
+    (
+        "depends_on unmet",
+        ("depends_on unmet", "depends_on", "依赖未满足"),
+    ),
+    (
+        "user asked serial",
+        ("user asked serial", "用户要求串行"),
+    ),
+    (
+        "conflict surface cannot isolate",
+        ("conflict surface cannot isolate", "conflict surface", "冲突面无法隔离"),
+    ),
+    (
+        LITE_SERIAL_REASON,
+        ("single write-set", "single write set", "真·单写集", "真单写集"),
+    ),
+)
+
+_KEY_LINE_RE = re.compile(
+    r"^(?:[-*]\s+)?`?([A-Za-z_][A-Za-z0-9_]*)`?\s*:\s*(.+?)\s*$"
+)
+_HOST_FORBIDDEN = ("Multitask", "SwitchMode", "CreateGoal")
+
+
+def evaluate_parallel_declaration(
+    task_dir: Path | str,
+    task_data: dict[str, Any] | None = None,
+    *,
+    inline_only: bool | None = None,
+) -> dict[str, Any]:
+    """Return a Check verdict for the P38 declaration XOR.
+
+    ``result`` is PASS / FAIL / SKIP. Lite without a fake-parallel claim is SKIP.
+    """
+    path = Path(task_dir)
+    data = dict(task_data or {})
+    if not data:
+        loaded = _read_json(path / "task.json")
+        if loaded:
+            data = loaded
+
+    declaration = load_planning_declaration(path)
+    profile = resolve_declaration_profile(path, data, declaration)
+    units = extract_parallel_units(declaration)
+    serial_reason = extract_serial_reason(declaration)
+    mode = declaration.get("execution_mode")
+    inferred_inline = mode == "inline" if inline_only is None else bool(inline_only)
+    errors: list[str] = []
+
+    overlap = overlapping_write_sets(
+        units,
+        declaration.get("children") if isinstance(declaration.get("children"), list) else [],
+        group_isolation=declaration.get("isolation"),
+    )
+    if overlap:
+        errors.append(
+            "write-sets overlap without isolation (fake parallel): "
+            + "; ".join(f"{touch} → {', '.join(ids)}" for touch, ids in overlap)
+        )
+
+    if profile == "lite":
+        if errors:
+            return _verdict(
+                False,
+                "FAIL",
+                profile,
+                errors,
+                units,
+                serial_reason,
+                declaration,
+            )
+        return _verdict(True, "SKIP", profile, [], units, serial_reason, declaration)
+
+    has_groups = bool(units)
+    has_reason = bool(serial_reason)
+    if not has_groups and not has_reason:
+        errors.append(
+            "Full/Parent planning must declare parallel_groups (or stages) or serial_reason"
+        )
+    if serial_reason and normalize_serial_reason(serial_reason) is None:
+        errors.append(f"serial_reason is not in the P18/P38 set: {serial_reason}")
+    if has_groups and inferred_inline and not has_reason:
+        errors.append(
+            "isolatable groups declared but write-set work stayed inline without serial_reason"
+        )
+
+    ok = not errors
+    return _verdict(
+        ok,
+        "PASS" if ok else "FAIL",
+        profile,
+        errors,
+        units,
+        serial_reason,
+        declaration,
+    )
+
+
+def load_planning_declaration(task_dir: Path | str) -> dict[str, Any]:
+    """Merge task-map.md (wins) with implement.md gap-fill."""
+    path = Path(task_dir)
+    merged: dict[str, Any] = {}
+    map_data, _body = load_task_map(path)
+    if isinstance(map_data, dict):
+        merged.update(map_data)
+    implement = path / "implement.md"
+    if implement.is_file():
+        try:
+            impl = parse_declaration_text(implement.read_text(encoding="utf-8"))
+        except OSError:
+            impl = {}
+        for key, value in impl.items():
+            current = merged.get(key)
+            if current in (None, "", [], {}) or key not in merged:
+                merged[key] = value
+    return merged
+
+
+def parse_declaration_text(text: str) -> dict[str, Any]:
+    """Parse YAML frontmatter plus body ``key: value`` lines (implement.md)."""
+    data: dict[str, Any] = {}
+    frontmatter, body = _split_frontmatter(text)
+    if frontmatter:
+        data.update(_parse_simple_mapping(frontmatter))
+    data.update(_parse_simple_mapping(body if frontmatter else text))
+    return data
+
+
+def extract_parallel_units(declaration: dict[str, Any]) -> list[str]:
+    units: list[str] = []
+    groups = declaration.get("parallel_groups")
+    if isinstance(groups, list):
+        units.extend(_unique_strings(groups))
+    elif isinstance(groups, str) and groups.strip():
+        units.extend(_unique_strings(_parse_inline_list(groups)))
+    stages = declaration.get("stages")
+    if isinstance(stages, list):
+        for stage in stages:
+            if not isinstance(stage, dict):
+                continue
+            stage_units = stage.get("units")
+            if isinstance(stage_units, list):
+                units.extend(_unique_strings(stage_units))
+            elif isinstance(stage_units, str) and stage_units.strip():
+                units.extend(_unique_strings(_parse_inline_list(stage_units)))
+    return _unique_strings(units)
+
+
+def extract_serial_reason(declaration: dict[str, Any]) -> str | None:
+    raw = declaration.get("serial_reason")
+    if isinstance(raw, str) and raw.strip():
+        return raw.strip()
+    return None
+
+
+def normalize_serial_reason(raw: str) -> str | None:
+    text = raw.strip().lower()
+    for canonical, aliases in _SERIAL_ALIASES:
+        for alias in aliases:
+            if alias.lower() in text or text == alias.lower():
+                return canonical
+    return None
+
+
+def overlapping_write_sets(
+    units: list[str],
+    children: list[Any],
+    *,
+    group_isolation: str | None = None,
+) -> list[tuple[str, list[str]]]:
+    """Return (touch, unit-ids) for shared write-sets that are not isolated."""
+    if group_isolation == "git-worktree":
+        return []
+    by_id = {
+        child.get("id"): child
+        for child in children
+        if isinstance(child, dict) and isinstance(child.get("id"), str)
+    }
+    owners: dict[str, list[str]] = {}
+    for unit in units:
+        child = by_id.get(unit) or {}
+        isolation = child.get("isolation")
+        if isolation == "git-worktree":
+            continue
+        touches = child.get("touches")
+        if not isinstance(touches, list):
+            continue
+        for touch in touches:
+            if not isinstance(touch, str) or not touch.strip():
+                continue
+            owners.setdefault(touch.strip(), []).append(unit)
+    return [
+        (touch, ids)
+        for touch, ids in owners.items()
+        if len(_unique_strings(ids)) > 1
+    ]
+
+
+def resolve_declaration_profile(
+    task_dir: Path | str,
+    task_data: dict[str, Any],
+    declaration: dict[str, Any],
+) -> str:
+    topology = task_data.get("topology")
+    if isinstance(topology, dict) and topology.get("kind") == "parent-child":
+        return "parent"
+    children = task_data.get("children")
+    if isinstance(children, list) and children:
+        return "parent"
+    map_children = declaration.get("children")
+    if isinstance(map_children, list) and any(
+        isinstance(child, dict) and child.get("id") for child in map_children
+    ):
+        return "parent"
+    if (Path(task_dir) / "task-map.md").is_file() and extract_parallel_units(declaration):
+        return "parent"
+    if rigor_from_required_controls(task_data) == "full":
+        return "full"
+    return "lite"
+
+
+def host_forbidden_terms() -> tuple[str, ...]:
+    return _HOST_FORBIDDEN
+
+
+def _verdict(
+    ok: bool,
+    result: str,
+    profile: str,
+    errors: list[str],
+    units: list[str],
+    serial_reason: str | None,
+    declaration: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "schema_version": PARALLEL_DECLARATION_SCHEMA_VERSION,
+        "source": PARALLEL_DECLARATION_SOURCE,
+        "readonly": True,
+        "ok": ok,
+        "result": result,
+        "profile": profile,
+        "errors": list(errors),
+        "has_parallel_groups": bool(units),
+        "has_serial_reason": bool(serial_reason),
+        "units": list(units),
+        "serial_reason": serial_reason,
+        "execution_mode": declaration.get("execution_mode"),
+    }
+
+
+def _split_frontmatter(content: str) -> tuple[str | None, str]:
+    lines = content.splitlines(keepends=True)
+    if not lines or lines[0].strip() != "---":
+        return None, content
+    for idx in range(1, len(lines)):
+        if lines[idx].strip() == "---":
+            return "".join(lines[1:idx]), "".join(lines[idx + 1 :])
+    return None, content
+
+
+def _parse_simple_mapping(text: str) -> dict[str, Any]:
+    data: dict[str, Any] = {}
+    for raw in text.splitlines():
+        stripped = raw.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        match = _KEY_LINE_RE.match(stripped)
+        if not match:
+            continue
+        key = match.group(1)
+        value = _parse_scalar(match.group(2).strip().strip("`"))
+        if key in data and data[key] not in (None, "", [], {}):
+            continue
+        data[key] = value
+    return data
+
+
+def _parse_scalar(value: str) -> Any:
+    if value == "null":
+        return None
+    if value == "[]":
+        return []
+    if value.startswith("[") and value.endswith("]"):
+        return _parse_inline_list(value)
+    return value.strip("'\"")
+
+
+def _parse_inline_list(value: str) -> list[str]:
+    inner = value.strip()
+    if inner.startswith("[") and inner.endswith("]"):
+        inner = inner[1:-1]
+    if not inner.strip():
+        return []
+    return [item.strip().strip("'\"") for item in inner.split(",") if item.strip()]
+
+
+def _unique_strings(values: list[Any]) -> list[str]:
+    out: list[str] = []
+    for value in values:
+        if not isinstance(value, str):
+            continue
+        item = value.strip()
+        if item and item not in out:
+            out.append(item)
+    return out
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        parsed = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def main(argv: list[str] | None = None) -> int:
+    import sys
+
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args:
+        sys.stderr.write("usage: parallel_declaration.py <task-dir>\n")
+        return 2
+    payload = evaluate_parallel_declaration(Path(args[0]))
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False, indent=2) + "\n")
+    return 0 if payload.get("ok") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())