@harmonyos-arkts/d2h 0.1.27 → 0.1.28

package/skills/d2h-architecture-plan/scripts/architecture_plan.py

@@ -1,31 +1,20 @@
 #!/usr/bin/env python3
-"""Validate dashboard architecture plans and record a user-selected directory scheme.
+"""Read-only validation of the confirmed architecture shown on the dashboard.
 
-Standard library only. This helper never creates a HarmonyOS project or directory shell.
-The caller must serialize writes and establish that a request came from the user.
+Standard library only. User answers and authorization stay in architecture-plan.md;
+valid JSON is neither proof of confirmation nor permission to create a project.
 """
 
 from __future__ import annotations
 
 import argparse
-import copy
 import json
-import os
 from pathlib import Path, PurePosixPath
 import re
 import sys
-import tempfile
 
 
-PROPOSAL_IDS = {"android-mirror", "harmony-practice", "hybrid"}
-PLAN_FIELDS = {
-    "planId", "project", "androidAnalysis", "proposals",
-    "recommendedProposalId", "recommendationReason", "selectedProposalId",
-}
-DECISION_FIELDS = {
-    "requestId", "planId", "selectedProposalId",
-    "action", "source", "notes",
-}
+PLAN_FIELDS = {"projectName", "directoryTree", "decisions"}
 
 
 class ContractError(ValueError):
@@ -46,9 +35,8 @@ def record(value: object, fields: set[str], label: str, *, optional: set[str] |
     return value
 
 
-def string(value: object, label: str, *, empty: bool = False) -> str:
-    require(isinstance(value, str) and (empty or bool(value.strip())),
-            f"{label} must be {'a' if empty else 'a non-empty'} string")
+def string(value: object, label: str) -> str:
+    require(isinstance(value, str) and bool(value.strip()), f"{label} must be a non-empty string")
     return value
 
 
@@ -61,21 +49,21 @@ def array(value: object, label: str, *, nonempty: bool = False) -> list:
 def relative_path(value: object, label: str) -> str:
     value = string(value, label)
     require(value == "." or all(
-        part not in ("", ".", "..") and
+        part not in ("", ".", "..", "…") and
         not re.search(r'[<>:"\\|?*{}\x00-\x1f]', part) and
         not part.endswith((".", " ")) and
-        not re.fullmatch(r"(?i:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\..*)?", part)
+        not re.fullmatch(r"(?i:CON|PRN|AUX|NUL|COM[1-9¹²³]|LPT[1-9¹²³])(?:\..*)?", part)
         for part in value.split("/")
     ), f"{label} must be a normalized, safe root-relative directory path")
     return value
 
 
-def directory_tree(value: object, label: str) -> set[str]:
+def directory_tree(value: object, label: str = "directoryTree") -> set[str]:
     paths: set[str] = set()
     folded: set[str] = set()
     hap_paths: list[str] = []
 
-    def visit(node: object, parent: str | None, module_parent: bool) -> None:
+    def visit(node: object, parent: str | None, module_roots: tuple[str, ...]) -> None:
         node = record(node, {"name", "path", "description", "children"}, label, optional={"kind"})
         name = string(node["name"], f"{label}.name")
         path = relative_path(node["path"], f"{label}.path")
@@ -89,120 +77,36 @@ def directory_tree(value: object, label: str) -> set[str]:
                     str(PurePosixPath(path).parent) == parent,
                     f"{label}[{path}] must be a direct child of {parent}, named by its last segment")
         require(path.casefold() not in folded, f"{label}: duplicate/case-conflicting path {path}")
-        require(not module_parent or kind == "directory", f"{label}[{path}]: nested module")
+        require(kind == "directory" or all(
+            path != f"{root}/src" and not path.startswith(f"{root}/src/") for root in module_roots
+        ), f"{label}[{path}]: module inside another module's source tree")
         if kind == "HAP":
             hap_paths.append(path)
         paths.add(path)
         folded.add(path.casefold())
+        child_roots = module_roots + (path,) if kind != "directory" else module_roots
         for child in array(node["children"], f"{label}[{path}].children"):
-            visit(child, path, module_parent or kind != "directory")
+            visit(child, path, child_roots)
 
-    visit(value, None, False)
+    visit(value, None, ())
     require(bool(hap_paths), f"{label} must include an application HAP")
     for path in hap_paths:
-        require(f"{path}/src/main/ets" in paths, f"{label}[{path}] must include its src/main/ets source root")
+        production_root = f"{path}/src/main"
+        require(production_root in paths and any(p.startswith(f"{production_root}/") for p in paths),
+                f"{label}[{path}] must include an expanded src/main production root with key directories")
     return paths
 
 
-def reference(value: object, allowed: set[str], label: str) -> str:
-    value = string(value, label)
-    require(value in allowed, f"{label}: unknown reference {value}")
-    return value
-
-
-def validate_decision(value: object) -> dict:
-    decision = record(value, DECISION_FIELDS, "selection")
-    for key in ("requestId", "planId"):
-        string(decision[key], f"selection.{key}")
-    reference(decision["selectedProposalId"], PROPOSAL_IDS, "selection.selectedProposalId")
-    require(decision["action"] in ("select", "select-and-create"), "selection.action invalid")
-    require(decision["source"] in ("dashboard", "question", "conversation"), "selection.source invalid")
-    string(decision["notes"], "selection.notes", empty=True)
-    return decision
-
-
 def validate_plan(value: object) -> dict:
     plan = record(value, PLAN_FIELDS, "plan")
-    string(plan["planId"], "planId")
-    project = record(plan["project"], {"name", "summary"}, "project")
-    for key in ("name", "summary"):
-        string(project[key], f"project.{key}")
-
-    analysis = record(plan["androidAnalysis"], {"summary", "techStack", "risks"}, "androidAnalysis")
-    string(analysis["summary"], "androidAnalysis.summary")
-    stack = record(analysis["techStack"], {"language", "ui", "storage", "network"}, "androidAnalysis.techStack")
-    for key in ("language", "ui", "storage", "network"):
-        string(stack[key], f"androidAnalysis.techStack.{key}")
-    risks = array(analysis["risks"], "androidAnalysis.risks")
-    require(len(risks) <= 5, "androidAnalysis.risks must contain at most five key risks")
-    for risk in risks:
-        risk = record(risk, {"title", "impact"}, "androidAnalysis.risks[]")
-        string(risk["title"], "androidAnalysis.risks[].title")
-        string(risk["impact"], "androidAnalysis.risks[].impact")
-
-    proposals = array(plan["proposals"], "proposals", nonempty=True)
-    require(len(proposals) == 3, "proposals must contain exactly three schemes")
-    proposal_ids: set[str] = set()
-    for proposal in proposals:
-        proposal = record(proposal, {"id", "name", "summary", "directoryTree"}, "proposal")
-        proposal_id = reference(proposal["id"], PROPOSAL_IDS, "proposal.id")
-        require(proposal_id not in proposal_ids, f"duplicate proposal ID: {proposal_id}")
-        proposal_ids.add(proposal_id)
-        for key in ("name", "summary"):
-            string(proposal[key], f"{proposal_id}.{key}")
-        directory_tree(proposal["directoryTree"], f"{proposal_id}.directoryTree")
-
-    reference(plan["recommendedProposalId"], proposal_ids, "recommendedProposalId")
-    string(plan["recommendationReason"], "recommendationReason")
-    if plan["selectedProposalId"] is not None:
-        reference(plan["selectedProposalId"], proposal_ids, "selectedProposalId")
-    return plan
+    string(plan["projectName"], "projectName")
+    directory_tree(plan["directoryTree"])
+    for decision in array(plan["decisions"], "decisions", nonempty=True):
+        decision = record(decision, {"title", "description"}, "decisions[]")
+        for key in ("title", "description"):
+            string(decision[key], f"decisions[].{key}")
 
-
-def apply_selection(plan: dict, decision: dict, saved: dict | None = None) -> tuple[dict, dict]:
-    """Return a validated new plan and continuation instruction; no filesystem effects."""
-    validate_plan(plan)
-    validate_decision(decision)
-    require(decision["planId"] == plan["planId"], "planId mismatch; refresh the displayed plan")
-    if saved is not None:
-        validate_decision(saved)
-    if saved is not None and decision["requestId"] == saved["requestId"]:
-        require(decision == saved, "requestId already used with different content")
-    if decision == saved and plan["selectedProposalId"] == decision["selectedProposalId"]:
-        status = "already-applied"
-        updated = plan
-    else:
-        updated = copy.deepcopy(plan)
-        updated["selectedProposalId"] = decision["selectedProposalId"]
-        validate_plan(updated)
-        status = "applied"
-    return updated, {
-        "status": status,
-        "planId": updated["planId"],
-        "selectedProposalId": updated["selectedProposalId"],
-        "nextAction": "create-directory-shell" if decision["action"] == "select-and-create" else "selection-recorded",
-    }
-
-
-def read_selection(plan: dict, decision: dict) -> tuple[dict, dict]:
-    """Resolve only a persisted confirmation matching the plan's selected ID."""
-    validate_plan(plan)
-    validate_decision(decision)
-    require(plan["selectedProposalId"] is not None, "no confirmed proposal selected")
-    require(decision["planId"] == plan["planId"] and
-            decision["selectedProposalId"] == plan["selectedProposalId"],
-            "confirmation does not match the plan/selected proposal")
-    proposal = next(p for p in plan["proposals"] if p["id"] == plan["selectedProposalId"])
-    return proposal, {
-        "status": "confirmed",
-        "planId": plan["planId"],
-        "selectedProposalId": proposal["id"],
-        "requestId": decision["requestId"],
-        "source": decision["source"],
-        "action": decision["action"],
-        "notes": decision["notes"],
-        "nextAction": "create-directory-shell" if decision["action"] == "select-and-create" else "selection-recorded",
-    }
+    return plan
 
 
 def unique_keys(pairs: list[tuple[str, object]]) -> dict:
@@ -222,57 +126,19 @@ def load_json(path: Path) -> object:
                       parse_constant=reject_constant)
 
 
-def save_json(path: Path, value: dict) -> None:
-    temporary = None
-    try:
-        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent,
-                                         prefix=f".{path.name}.", suffix=".tmp", delete=False) as stream:
-            temporary = Path(stream.name)
-            json.dump(value, stream, ensure_ascii=False, indent=2)
-            stream.write("\n")
-        os.replace(temporary, path)
-    finally:
-        if temporary is not None and temporary.exists():
-            temporary.unlink()
-
-
 def main() -> int:
     if hasattr(sys.stdout, "reconfigure"):
         sys.stdout.reconfigure(encoding="utf-8")
     parser = argparse.ArgumentParser(description=__doc__)
     subparsers = parser.add_subparsers(dest="command", required=True)
-    check = subparsers.add_parser("validate", help="read-only plan validation")
+    check = subparsers.add_parser("validate", help="read-only final-plan validation")
     check.add_argument("plan", type=Path)
-    apply = subparsers.add_parser("apply-selection", help="record a real user request; never creates a project")
-    apply.add_argument("plan", type=Path)
-    apply.add_argument("decision", type=Path)
-    apply.add_argument("--recover", action="store_true", help="reuse the script-owned confirmation after an interrupted apply")
-    read = subparsers.add_parser("read-selection", help="reload the saved confirmation before directory implementation")
-    read.add_argument("plan", type=Path)
     args = parser.parse_args()
     try:
         plan = validate_plan(load_json(args.plan))
-        if args.command == "validate":
-            result = {"status": "valid", "planId": plan["planId"]}
-        elif args.command == "apply-selection":
-            confirmation_file = args.plan.parent / "architecture-selection.json"
-            same_file = args.decision.resolve() == confirmation_file.resolve()
-            require(same_file == args.recover,
-                    "new submissions need a separate input file; use --recover only with architecture-selection.json")
-            decision = load_json(args.decision)
-            saved = load_json(confirmation_file) if confirmation_file.exists() else None
-            updated, result = apply_selection(plan, decision, saved)
-            # Persist confirmation first. If the selected ID changes and the
-            # second write fails, read-selection rejects the mismatch.
-            if saved != decision:
-                save_json(confirmation_file, decision)
-            if result["status"] == "applied":
-                save_json(args.plan, updated)
-        else:
-            _, result = read_selection(plan, load_json(args.plan.parent / "architecture-selection.json"))
-        print(json.dumps(result, ensure_ascii=False))
+        print(json.dumps({"status": "valid", "projectName": plan["projectName"]}, ensure_ascii=False))
         return 0
-    except (ContractError, OSError, ValueError, RecursionError) as error:
+    except (OSError, ValueError, RecursionError) as error:
         print(json.dumps({"status": "error", "error": str(error)}, ensure_ascii=False))
         return 1