superlab 0.1.63 → 0.1.65

package/package-assets/shared/lab/.managed/scripts/paper_topology.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+
+DEPRECATION_MARKERS = ("archived", "deprecated", "legacy", "out-of-band", "归档", "废弃", "旧层", "旁路", "历史")
+PATH_TOKEN_PATTERN = re.compile(
+    r"(/[^ \t\n\r)]+|(?:[A-Za-z0-9_.-]+/)+[A-Za-z0-9_.\-/]+)"
+)
+
+
+def find_project_root(start_path: Path) -> Path | None:
+    for parent in (start_path, *start_path.parents):
+        workflow_config = parent / ".lab" / "config" / "workflow.json"
+        if workflow_config.exists():
+            return parent
+    return None
+
+
+def load_workflow_config(project_root: Path | None) -> dict:
+    if project_root is None:
+        return {}
+    workflow_config = project_root / ".lab" / "config" / "workflow.json"
+    if not workflow_config.exists():
+        return {}
+    try:
+        return json.loads(workflow_config.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def resolve_paper_topology(project_root: Path, workflow_config: dict | None = None) -> dict:
+    config = workflow_config or load_workflow_config(project_root)
+    deliverables_root = (project_root / config.get("deliverables_root", "docs/research")).resolve()
+    canonical_root = (deliverables_root / "paper").resolve()
+    workflow_language = config.get("workflow_language", "")
+    paper_language = config.get("paper_language", "")
+    workflow_language_active = bool(workflow_language and paper_language and workflow_language != paper_language)
+    workflow_root = (canonical_root / "workflow-language").resolve() if workflow_language_active else None
+    return {
+        "project_root": project_root.resolve(),
+        "deliverables_root": deliverables_root,
+        "canonical_root": canonical_root,
+        "workflow_root": workflow_root,
+        "workflow_language_active": workflow_language_active,
+    }
+
+
+def normalize_path(path_value: str | Path, project_root: Path) -> Path:
+    path_obj = Path(path_value)
+    return path_obj.resolve() if path_obj.is_absolute() else (project_root / path_obj).resolve()
+
+
+def is_within(candidate: Path, root: Path | None) -> bool:
+    if root is None:
+        return False
+    try:
+        candidate.relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def classify_paper_path(path_value: str | Path, topology: dict) -> tuple[str, Path]:
+    candidate = normalize_path(path_value, topology["project_root"])
+    if topology["workflow_language_active"] and is_within(candidate, topology["workflow_root"]):
+        return "active-workflow-language", candidate
+    if is_within(candidate, topology["canonical_root"]):
+        return "active-canonical", candidate
+
+    parts = candidate.parts
+    if any(part.startswith("review_") or part.startswith("translation_") or part.startswith("sections_") for part in parts):
+        return "legacy-paper-layer", candidate
+    if "deliverables" in parts and ("sections" in parts or "workflow-language" in parts):
+        return "legacy-paper-layer", candidate
+    if "docs" in parts and "lab" in parts and "paper" in parts:
+        return "legacy-paper-layer", candidate
+    return "out-of-band", candidate
+
+
+def line_is_deprecated(line: str) -> bool:
+    lowered = line.lower()
+    return any(marker in lowered for marker in DEPRECATION_MARKERS)
+
+
+def iter_path_tokens(text: str):
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        for match in PATH_TOKEN_PATTERN.finditer(line):
+            yield line_number, line, match.group(1)

package/package-assets/shared/lab/.managed/scripts/render_rule_preflight.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+from validate_rule_preflight import compute_preflight_stamp
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Render or inject a machine-generated Rule Preflight block for a managed lab stage artifact."
+    )
+    parser.add_argument("--artifact", required=True, help="Markdown artifact to update in place")
+    parser.add_argument("--stage", required=True, help="Stage name, e.g. write or auto")
+    parser.add_argument("--project-root", required=True, help="Project root containing .lab/.managed/rule-manifest.json")
+    parser.add_argument("--mode", required=True, help="Resolved mode for this round")
+    parser.add_argument("--target", required=True, help="Resolved target for this round")
+    parser.add_argument("--override-reason", default="", help="Optional override reason")
+    parser.add_argument("--lang", choices=("en", "zh"), default="en", help="Render language for the section")
+    return parser.parse_args()
+
+
+def read_manifest(project_root: Path, stage: str) -> dict:
+    manifest_path = project_root / ".lab" / ".managed" / "rule-manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    stage_entry = (manifest.get("stages") or {}).get(stage)
+    if not stage_entry:
+        raise SystemExit(f"stage `{stage}` is missing from {manifest_path}")
+    return {
+        "rule_source_file": stage_entry.get("rule_source_file", ""),
+        "rule_source_revision": stage_entry.get("rule_source_revision", ""),
+        "project_version": manifest.get("package_version", ""),
+    }
+
+
+def render_preflight_block(values: dict[str, str], lang: str) -> str:
+    values = dict(values)
+    values["preflight_stamp"] = compute_preflight_stamp(values)
+    if lang == "zh":
+        lines = [
+            "## 规则预检",
+            "",
+            f"- 规则来源文件: {values['rule_source_file']}",
+            f"- 规则来源修订: {values['rule_source_revision']}",
+            f"- 项目版本: {values['project_version']}",
+            f"- 解析后的阶段: {values['resolved_stage']}",
+            f"- 解析后的模式: {values['resolved_mode']}",
+            f"- 解析后的目标: {values['resolved_target']}",
+            f"- 预检签名: {values['preflight_stamp']}",
+            f"- 如有覆盖理由: {values['override_reason']}",
+            "",
+        ]
+    else:
+        lines = [
+            "## Rule Preflight",
+            "",
+            f"- Rule source file: {values['rule_source_file']}",
+            f"- Rule source revision: {values['rule_source_revision']}",
+            f"- Project version: {values['project_version']}",
+            f"- Resolved stage: {values['resolved_stage']}",
+            f"- Resolved mode: {values['resolved_mode']}",
+            f"- Resolved target: {values['resolved_target']}",
+            f"- Preflight stamp: {values['preflight_stamp']}",
+            f"- Override reason, if any: {values['override_reason']}",
+            "",
+        ]
+    return "\n".join(lines)
+
+
+def replace_or_insert_rule_preflight(text: str, block: str) -> str:
+    pattern = re.compile(r"^##\s+(?:Rule Preflight|规则预检)\s*$", flags=re.MULTILINE)
+    match = pattern.search(text)
+    if match:
+        start = match.start()
+        next_heading = re.search(r"^##\s+", text[match.end():], flags=re.MULTILINE)
+        end = match.end() + next_heading.start() if next_heading else len(text)
+        prefix = text[:start].rstrip() + "\n\n"
+        suffix = text[end:].lstrip("\n")
+        return prefix + block.rstrip() + ("\n\n" + suffix if suffix else "\n")
+
+    title_match = re.search(r"^# .*$", text, flags=re.MULTILINE)
+    if not title_match:
+        return block.rstrip() + "\n\n" + text.lstrip()
+    insert_at = title_match.end()
+    prefix = text[:insert_at].rstrip() + "\n\n"
+    suffix = text[insert_at:].lstrip("\n")
+    return prefix + block.rstrip() + ("\n\n" + suffix if suffix else "\n")
+
+
+def main():
+    args = parse_args()
+    artifact_path = Path(args.artifact)
+    project_root = Path(args.project_root)
+    values = read_manifest(project_root, args.stage)
+    values.update(
+        {
+            "resolved_stage": args.stage,
+            "resolved_mode": args.mode,
+            "resolved_target": args.target,
+            "override_reason": args.override_reason,
+        }
+    )
+    block = render_preflight_block(values, args.lang)
+    original = artifact_path.read_text(encoding="utf-8") if artifact_path.exists() else ""
+    updated = replace_or_insert_rule_preflight(original, block)
+    artifact_path.parent.mkdir(parents=True, exist_ok=True)
+    artifact_path.write_text(updated, encoding="utf-8")
+    print("rule preflight written")
+
+
+if __name__ == "__main__":
+    main()

package/package-assets/shared/lab/.managed/scripts/validate_manuscript_delivery.py

@@ -5,6 +5,7 @@ import re
 import sys
 from pathlib import Path
 from validate_rule_preflight import validate_rule_preflight
+from validate_paper_topology import validate_topology_artifacts
 
 
 ABSOLUTE_PATH_MARKERS = ("/Users/", "/home/", "/tmp/", "/private/tmp/")
@@ -148,6 +149,54 @@ def extract_table_note(text: str) -> str:
     return "\n".join(line.strip() for line in text.splitlines() if line.strip().startswith("%"))
 
 
+def extract_tabular_specs(text: str) -> list[str]:
+    return re.findall(r"\\begin\{tabular\}(?:\[[^\]]*\])?\{([^}]*)\}", text)
+
+
+def extract_tabular_bodies(text: str) -> list[str]:
+    return [
+        match.group(1)
+        for match in re.finditer(
+            r"\\begin\{tabular\}(?:\[[^\]]*\])?\{[^}]*\}([\s\S]*?)\\end\{tabular\}",
+            text,
+        )
+    ]
+
+
+def strip_latex_for_table_cell(cell: str) -> str:
+    cell = re.sub(r"%.*", "", cell)
+    cell = re.sub(r"\\(?:textbf|mathbf|emph)\{([^}]*)\}", r"\1", cell)
+    cell = re.sub(r"\\[A-Za-z@*]+(?:\[[^\]]*\])?", " ", cell)
+    cell = cell.replace("$", " ")
+    return cell.strip()
+
+
+def check_numeric_precision_consistency(text: str, issues: list[str], label: str):
+    for body in extract_tabular_bodies(text):
+        column_precisions: dict[int, set[int]] = {}
+        rows = re.split(r"\\\\", body)
+        for row in rows:
+            row = re.sub(r"\\(?:toprule|midrule|bottomrule|cmidrule)(?:\{[^}]*\})?", " ", row)
+            if "&" not in row:
+                continue
+            cells = [strip_latex_for_table_cell(cell) for cell in row.split("&")]
+            for index, cell in enumerate(cells):
+                matches = re.findall(r"(?<![A-Za-z])[-+]?\d+\.(\d+)", cell)
+                if not matches:
+                    continue
+                column_precisions.setdefault(index, set()).update(len(match) for match in matches)
+        inconsistent_columns = [
+            str(index + 1)
+            for index, precisions in sorted(column_precisions.items())
+            if len(precisions) > 1
+        ]
+        if inconsistent_columns:
+            issues.append(
+                f"{label} has inconsistent numeric precision in column(s): {', '.join(inconsistent_columns)}"
+            )
+            return
+
+
 def detect_uppercase_abbreviations(text: str) -> set[str]:
     return {
         token
@@ -209,8 +258,16 @@ def check_table_file(path: Path, issues: list[str], label: str):
         issues.append(f"{label} must contain a table environment")
     if r"\caption{" not in text or r"\label{" not in text:
         issues.append(f"{label} must contain both caption and label")
+    first_caption = text.find(r"\caption{")
+    first_tabular = text.find(r"\begin{tabular}")
+    if first_caption != -1 and first_tabular != -1 and first_caption > first_tabular:
+        issues.append(f"{label} should place its caption before the tabular body")
     if not all(token in text for token in (r"\toprule", r"\midrule", r"\bottomrule")):
         issues.append(f"{label} must use booktabs structure")
+    if any("|" in spec for spec in extract_tabular_specs(text)) or r"\vline" in text:
+        issues.append(f"{label} must not use vertical table rules; use booktabs spacing instead")
+    if r"\hline" in text or r"\cline" in text:
+        issues.append(f"{label} must not mix legacy \\hline/\\cline rules with booktabs tables")
     if not all(marker in text for marker in REQUIRED_TABLE_NOTE_MARKERS):
         issues.append(f"{label} must include a local table note scaffold")
     caption_text = extract_caption(text)
@@ -233,6 +290,7 @@ def check_table_file(path: Path, issues: list[str], label: str):
             continue
         if value < 3.0:
             issues.append(f"{label} sets \\tabcolsep below the safe range for paper-facing main tables")
+    check_numeric_precision_consistency(text, issues, label)
 
 
 def check_figure_file(path: Path, issues: list[str], label: str):
@@ -609,6 +667,7 @@ def check_latest_write_iteration_preflight(paper_dir: Path, issues: list[str]):
         issues.append("missing latest write iteration needed for rule preflight validation")
         return
     issues.extend(validate_rule_preflight(latest_iteration, "write", project_root=project_root))
+    issues.extend(validate_topology_artifacts(project_root))
 
 
 def main():

package/package-assets/shared/lab/.managed/scripts/validate_paper_topology.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from paper_topology import (
+    classify_paper_path,
+    find_project_root,
+    iter_path_tokens,
+    line_is_deprecated,
+    resolve_paper_topology,
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Validate that plan/context artifacts point at the active paper topology instead of legacy side layers."
+    )
+    parser.add_argument("--project-root", required=True, help="Project root containing .lab/config/workflow.json")
+    return parser.parse_args()
+
+
+def read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def validate_file(file_path: Path, topology: dict, issues: list[str]):
+    if not file_path.exists():
+        return
+    text = read_text(file_path)
+    current_heading_deprecated = False
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        stripped = line.strip()
+        if stripped.startswith("#"):
+            current_heading_deprecated = line_is_deprecated(stripped)
+        for _, _, token in iter_path_tokens(line):
+            role, normalized_path = classify_paper_path(token, topology)
+            if role in {"active-canonical", "active-workflow-language"}:
+                continue
+            if current_heading_deprecated or line_is_deprecated(line):
+                continue
+            if role == "legacy-paper-layer":
+                issues.append(
+                    f"{file_path}:line {line_number} treats legacy-paper-layer path as active topology: {token} -> {normalized_path}"
+                )
+
+
+def validate_topology_artifacts(project_root: Path) -> list[str]:
+    topology = resolve_paper_topology(project_root)
+    files_to_check = [
+        project_root / ".lab" / "writing" / "plan.md",
+        topology["deliverables_root"] / "artifact-status.md",
+        project_root / ".lab" / "context" / "evidence-index.md",
+    ]
+
+    issues: list[str] = []
+    for file_path in files_to_check:
+        validate_file(file_path, topology, issues)
+    return issues
+
+
+def main():
+    args = parse_args()
+    project_root = find_project_root(Path(args.project_root).resolve())
+    if project_root is None:
+        print("could not find .lab/config/workflow.json for project root", file=sys.stderr)
+        return 1
+
+    issues = validate_topology_artifacts(project_root)
+
+    if issues:
+        for issue in issues:
+            print(issue, file=sys.stderr)
+        return 1
+
+    print("paper topology is consistent")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/package-assets/shared/lab/.managed/scripts/validate_rule_preflight.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+import argparse
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+
+SECTION_PATTERNS = (r"^##\s+Rule Preflight\s*$", r"^##\s+规则预检\s*$")
+FIELD_LABELS = {
+    "rule_source_file": ("Rule source file", "规则来源文件"),
+    "rule_source_revision": ("Rule source revision", "规则来源修订"),
+    "project_version": ("Project version", "项目版本"),
+    "resolved_stage": ("Resolved stage", "解析后的阶段"),
+    "resolved_mode": ("Resolved mode", "解析后的模式"),
+    "resolved_target": ("Resolved target", "解析后的目标"),
+    "preflight_stamp": ("Preflight stamp", "预检签名"),
+    "override_reason": ("Override reason, if any", "Override 理由（如有）"),
+}
+BASE_REQUIRED_FIELD_KEYS = (
+    "rule_source_file",
+    "rule_source_revision",
+    "project_version",
+    "resolved_stage",
+    "resolved_mode",
+    "resolved_target",
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Validate that a managed stage artifact records a consistent Rule Preflight block."
+    )
+    parser.add_argument("--artifact", required=True, help="Path to the managed stage artifact")
+    parser.add_argument("--stage", required=True, help="Stage name, e.g. write or auto")
+    parser.add_argument(
+        "--project-root",
+        required=False,
+        help="Optional project root; if omitted, infer it by walking upward for .lab/config/workflow.json",
+    )
+    return parser.parse_args()
+
+
+def read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def find_project_root(start_path: Path) -> Path | None:
+    for parent in (start_path.parent, *start_path.parents):
+        workflow_config = parent / ".lab" / "config" / "workflow.json"
+        if workflow_config.exists():
+            return parent
+    return None
+
+
+def extract_section_body(text: str, patterns: tuple[str, ...]) -> str:
+    for pattern in patterns:
+        match = re.search(pattern, text, flags=re.MULTILINE)
+        if not match:
+            continue
+        start = match.end()
+        next_heading = re.search(r"^##\s+", text[start:], flags=re.MULTILINE)
+        end = start + next_heading.start() if next_heading else len(text)
+        return text[start:end].strip()
+    return ""
+
+
+def extract_field_value(body: str, labels: tuple[str, ...]) -> str | None:
+    for label in labels:
+        pattern = re.compile(
+            rf"^\s*(?:-|\d+\.)\s*{re.escape(label)}[:：][ \t]*([^\n]+?)\s*$",
+            flags=re.MULTILINE,
+        )
+        for match in pattern.finditer(body):
+            return match.group(1).strip()
+    return None
+
+
+def has_meaningful_value(value: str | None) -> bool:
+    if value is None:
+        return False
+    normalized = value.strip().lower()
+    return normalized not in {"", "-", "n/a", "na", "none", "null", "todo", "tbd"}
+
+
+def compute_preflight_stamp(values: dict[str, str | None]) -> str:
+    payload = {
+        "ruleSourceFile": values.get("rule_source_file") or "",
+        "ruleSourceRevision": values.get("rule_source_revision") or "",
+        "projectVersion": values.get("project_version") or "",
+        "resolvedStage": values.get("resolved_stage") or "",
+        "resolvedMode": values.get("resolved_mode") or "",
+        "resolvedTarget": values.get("resolved_target") or "",
+        "overrideReason": values.get("override_reason") or "",
+    }
+    return hashlib.sha256(json.dumps(payload, ensure_ascii=False).encode("utf-8")).hexdigest()
+
+
+def validate_rule_preflight(artifact_path: Path, stage: str, project_root: Path | None = None) -> list[str]:
+    issues: list[str] = []
+    if project_root is None:
+        project_root = find_project_root(artifact_path)
+    if project_root is None:
+        issues.append("could not infer project root for rule preflight validation")
+        return issues
+
+    manifest_path = project_root / ".lab" / ".managed" / "rule-manifest.json"
+    if not manifest_path.exists():
+        issues.append(f"missing managed rule manifest: {manifest_path.as_posix()}")
+        return issues
+
+    try:
+        manifest = json.loads(read_text(manifest_path))
+    except json.JSONDecodeError:
+        issues.append(f"managed rule manifest is invalid JSON: {manifest_path.as_posix()}")
+        return issues
+
+    stage_entry = (manifest.get("stages") or {}).get(stage)
+    if not stage_entry:
+        issues.append(f"managed rule manifest does not define stage `{stage}`")
+        return issues
+
+    if not artifact_path.exists():
+        issues.append(f"artifact does not exist: {artifact_path.as_posix()}")
+        return issues
+
+    body = extract_section_body(read_text(artifact_path), SECTION_PATTERNS)
+    if not body:
+        issues.append("missing Rule Preflight section")
+        return issues
+
+    values = {
+        key: extract_field_value(body, labels)
+        for key, labels in FIELD_LABELS.items()
+    }
+    required_field_keys = list(BASE_REQUIRED_FIELD_KEYS)
+    if int(manifest.get("layout_version") or 0) >= 2:
+        required_field_keys.append("preflight_stamp")
+    missing = [key for key in required_field_keys if not has_meaningful_value(values[key])]
+    if missing:
+        pretty = ", ".join(FIELD_LABELS[key][0] for key in missing)
+        issues.append(f"missing required rule preflight fields: {pretty}")
+        return issues
+
+    if values["rule_source_file"] != stage_entry.get("rule_source_file"):
+        issues.append(
+            f"rule preflight source file mismatch: expected {stage_entry.get('rule_source_file')}, got {values['rule_source_file']}"
+        )
+    if values["rule_source_revision"] != stage_entry.get("rule_source_revision"):
+        issues.append(
+            "rule preflight source revision mismatch"
+        )
+    if values["project_version"] != manifest.get("package_version"):
+        issues.append(
+            f"rule preflight project version mismatch: expected {manifest.get('package_version')}, got {values['project_version']}"
+        )
+    if values["resolved_stage"].strip().lower() != stage.strip().lower():
+        issues.append(
+            f"rule preflight stage mismatch: expected {stage}, got {values['resolved_stage']}"
+        )
+    if int(manifest.get("layout_version") or 0) >= 2:
+        expected_stamp = compute_preflight_stamp(values)
+        if values["preflight_stamp"] != expected_stamp:
+            issues.append("rule preflight stamp mismatch")
+    return issues
+
+
+def main():
+    args = parse_args()
+    artifact_path = Path(args.artifact)
+    project_root = Path(args.project_root) if args.project_root else None
+    issues = validate_rule_preflight(artifact_path, args.stage, project_root=project_root)
+    if not issues:
+        print("rule preflight is valid")
+        return 0
+    for issue in issues:
+        print(issue, file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())