@guanlin4924/devflow-pi 0.1.0

package/plugins/devflow-quality/skills/workflow-generate-mainflow-cases/scripts/discover_codebases.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Discover codebases from .planning navigation and .context spec indexes."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+NAV_INDEX = Path(".planning/navigation/INDEX.md")
+SPEC_INDEX = Path(".context/spec/index.md")
+
+
+def clean_cell(value: str) -> str:
+    value = value.strip()
+    if value.startswith("`") and value.endswith("`"):
+        value = value[1:-1]
+    value = value.replace("`", "").strip()
+    return value
+
+
+def parse_markdown_tables(path: Path) -> list[list[dict[str, str]]]:
+    lines = path.read_text(encoding="utf-8").splitlines()
+    tables: list[list[dict[str, str]]] = []
+    idx = 0
+    while idx < len(lines):
+        line = lines[idx].strip()
+        if not line.startswith("|") or idx + 1 >= len(lines):
+            idx += 1
+            continue
+        sep = lines[idx + 1].strip()
+        if not sep.startswith("|") or "---" not in sep:
+            idx += 1
+            continue
+        headers = [clean_cell(cell) for cell in line.strip("|").split("|")]
+        rows: list[dict[str, str]] = []
+        idx += 2
+        while idx < len(lines) and lines[idx].strip().startswith("|"):
+            cells = [clean_cell(cell) for cell in lines[idx].strip().strip("|").split("|")]
+            if len(cells) == len(headers):
+                rows.append(dict(zip(headers, cells)))
+            idx += 1
+        tables.append(rows)
+    return tables
+
+
+def first_table_with(path: Path, required: set[str]) -> list[dict[str, str]]:
+    for table in parse_markdown_tables(path):
+        if table and required.issubset(set(table[0].keys())):
+            return table
+    return []
+
+
+def domain_for(type_value: str, spec_path: str) -> str:
+    lowered = f"{type_value} {spec_path}".lower()
+    if "frontend" in lowered or "前端" in lowered:
+        return "frontend"
+    if "backend" in lowered or "后端" in lowered:
+        return "backend"
+    return "unknown"
+
+
+def scan_profile(domain: str) -> dict[str, list[str]]:
+    if domain == "backend":
+        return {
+            "source_kinds": [
+                "router/controller",
+                "service/usecase",
+                "schema/dto/request/response",
+                "model/entity",
+                "API entry",
+            ]
+        }
+    if domain == "frontend":
+        return {
+            "source_kinds": [
+                "router",
+                "pages/views",
+                "api/client",
+                "types/contracts",
+                "stores/hooks/components",
+            ]
+        }
+    return {"source_kinds": []}
+
+
+def fail(message: str) -> None:
+    print(f"ERROR: {message}", file=sys.stderr)
+    raise SystemExit(2)
+
+
+def discover() -> dict:
+    if not NAV_INDEX.exists():
+        fail(f"missing {NAV_INDEX}")
+    if not SPEC_INDEX.exists():
+        fail(f"missing {SPEC_INDEX}")
+
+    nav_rows = first_table_with(NAV_INDEX, {"Name", "Path", "Type", "Navigation"})
+    # The actual spec/index.md uses "Codebase Spec" and "Stack Spec" column names
+    spec_rows = first_table_with(SPEC_INDEX, {"Codebase", "Type", "Codebase Spec", "Stack Spec"})
+    if not spec_rows:
+        spec_rows = first_table_with(SPEC_INDEX, {"Codebase", "Type", "Navigation", "Stack Key", "Spec"})
+
+    if not nav_rows:
+        fail(f"no codebase registry table found in {NAV_INDEX}")
+    if not spec_rows:
+        fail(f"no codebase specs table found in {SPEC_INDEX}")
+
+    # Normalize column names: map "Codebase Spec" -> "Spec", "Stack Spec" -> "Stack Key"
+    normalized_spec_rows = []
+    for row in spec_rows:
+        nr = {}
+        for k, v in row.items():
+            if k in ("Codebase Spec", "Spec"):
+                nr["Spec"] = v
+            elif k in ("Stack Spec", "Stack Key"):
+                nr["Stack Key"] = v
+            else:
+                nr[k] = v
+        normalized_spec_rows.append(nr)
+    spec_rows = normalized_spec_rows
+
+    specs_by_name = {row["Codebase"]: row for row in spec_rows}
+    codebases: list[dict] = []
+    errors: list[str] = []
+
+    for row in nav_rows:
+        name = row.get("Name", "").strip()
+        if not name or name not in specs_by_name:
+            continue
+        spec_row = specs_by_name[name]
+        root = row.get("Path", "").strip()
+        navigation = row.get("Navigation", "").strip() or spec_row.get("Navigation", "").strip()
+        spec = spec_row.get("Spec", "").strip()
+        type_value = spec_row.get("Type", "").strip() or row.get("Type", "").strip()
+        stack_key = spec_row.get("Stack Key", "").strip()
+
+        for label, value in (("root", root), ("navigation", navigation), ("spec", spec)):
+            if not value:
+                errors.append(f"{name}: missing {label}")
+
+        root_path = Path(root)
+        nav_path = Path(navigation)
+        spec_path = Path(spec)
+        if root and not root_path.exists():
+            errors.append(f"{name}: root does not exist: {root}")
+        if navigation and not nav_path.exists():
+            errors.append(f"{name}: navigation file does not exist: {navigation}")
+        if spec and not spec_path.exists():
+            errors.append(f"{name}: spec file does not exist: {spec}")
+
+        domain = domain_for(type_value, spec)
+        codebases.append(
+            {
+                "name": name,
+                "type": type_value,
+                "domain": domain,
+                "root": root.rstrip("/"),
+                "navigation": navigation,
+                "spec": spec,
+                "stack_key": stack_key,
+                "role": row.get("Role", "").strip(),
+                "scan_profile": scan_profile(domain),
+            }
+        )
+
+    if errors:
+        fail("; ".join(errors))
+    if not codebases:
+        fail("no valid codebases discovered")
+
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "sources": {
+            "navigation_index": str(NAV_INDEX),
+            "spec_index": str(SPEC_INDEX),
+        },
+        "codebases": codebases,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", required=True, help="Path to write codebase-discovery.json")
+    args = parser.parse_args()
+
+    data = discover()
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/devflow-quality/skills/workflow-generate-mainflow-cases/scripts/normalize_case_payloads.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Normalize draft mainflow case payloads into import payloads."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from copy import deepcopy
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+MAINFLOW_TAGS = {"api-mainflow", "ui-mainflow"}
+DEFAULT_UI_STRATEGY = {"mode": "structured_first", "fallback": "midscene"}
+VALID_TARGET_KEYS = {"css", "xpath", "label", "placeholder", "role", "name", "near_text", "exact"}
+
+
+def slugify(value: str, fallback: str) -> str:
+    text = re.sub(r"[^0-9A-Za-z_\-\u4e00-\u9fff]+", "_", value.strip()).strip("_")
+    return text or fallback
+
+
+def load_payload(path: Path) -> dict[str, Any]:
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    if isinstance(raw, list):
+        return {"metadata": {}, "cases": raw}
+    if isinstance(raw, dict) and isinstance(raw.get("cases"), list):
+        return raw
+    raise ValueError("draft payload must be a JSON object with cases[] or a JSON array")
+
+
+def clean_empty(value: Any, keep_empty_list_keys: set[str] | None = None, key: str | None = None) -> Any:
+    keep_empty_list_keys = keep_empty_list_keys or set()
+    if isinstance(value, dict):
+        cleaned = {}
+        for child_key, child_value in value.items():
+            child = clean_empty(child_value, keep_empty_list_keys, child_key)
+            if child in (None, "", {}, []):
+                if child == [] and child_key in keep_empty_list_keys:
+                    cleaned[child_key] = child
+                continue
+            cleaned[child_key] = child
+        return cleaned
+    if isinstance(value, list):
+        return [item for item in (clean_empty(item, keep_empty_list_keys, key) for item in value) if item not in (None, "", {}, [])]
+    return value
+
+
+def infer_mainflow_tag(case: dict[str, Any]) -> str:
+    tags = [tag for tag in case.get("tags") or [] if tag in MAINFLOW_TAGS]
+    if tags:
+        return "ui-mainflow" if "ui-mainflow" in tags else "api-mainflow"
+    dsl = case.get("dsl_json") or {}
+    drivers = {str(step.get("driver", "")).lower() for step in dsl.get("steps") or [] if isinstance(step, dict)}
+    if drivers & {"ui", "web"}:
+        return "ui-mainflow"
+    return "api-mainflow"
+
+
+def normalize_steps(steps: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    normalized: list[dict[str, Any]] = []
+    id_map: dict[str, str] = {}
+    used: set[str] = set()
+
+    for index, step in enumerate(steps, start=1):
+        step = deepcopy(step)
+        old_id = str(step.get("id") or "").strip()
+        base = slugify(old_id or str(step.get("name") or ""), f"step_{index:02d}")
+        new_id = f"s{index:02d}_{base}"
+        while new_id in used:
+            new_id = f"{new_id}_{index}"
+        used.add(new_id)
+        if old_id:
+            id_map[old_id] = new_id
+        step["id"] = new_id
+        step.setdefault("name", f"Step {index}")
+        step.setdefault("params", {})
+        step.setdefault("assertions", [])
+        step.setdefault("timeout_ms", 30_000)
+        step.setdefault("on_failure", "stop")
+        if step.get("driver") == "ui":
+            step.setdefault("strategy", deepcopy(DEFAULT_UI_STRATEGY))
+        normalized.append(step)
+
+    for index, step in enumerate(normalized):
+        raw_deps = step.get("depends_on")
+        if raw_deps is None:
+            deps = [] if index == 0 else [normalized[index - 1]["id"]]
+        else:
+            deps = [id_map.get(str(dep), str(dep)) for dep in raw_deps]
+        step["depends_on"] = deps
+
+    # --- validate target keys (hard gate) ---
+    target_errors: list[str] = []
+    for step in normalized:
+        if step.get("driver") != "ui":
+            continue
+        target = step.get("target") or {}
+        unknown = set(target.keys()) - VALID_TARGET_KEYS
+        if unknown:
+            target_errors.append(
+                f"step '{step.get('id')}' (name='{step.get('name')}') target has invalid keys {sorted(unknown)}. "
+                f"Valid keys: {sorted(VALID_TARGET_KEYS)}. "
+                f"Current target: {json.dumps(target, ensure_ascii=False)}. "
+                f"Hint: use flat keys like {{\"label\": \"...\"}} or {{\"css\": \"...\"}} or {{\"placeholder\": \"...\"}}, "
+                f"NOT {{\"by\": \"...\", \"value\": \"...\"}}."
+            )
+    if target_errors:
+        raise ValueError(
+            "Normalization BLOCKED — invalid target keys found. Fix the draft DSL and re-run:\n"
+            + "\n".join(f"  - {e}" for e in target_errors)
+        )
+
+    return [clean_empty(step, keep_empty_list_keys={"assertions", "depends_on"}) for step in normalized]
+
+
+def normalize_case(case: dict[str, Any], metadata: dict[str, Any]) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    case = deepcopy(case)
+    evidence = list(case.pop("source_evidence", []) or [])
+    dsl = deepcopy(case.get("dsl_json") or {})
+    case_name = str(case.get("name") or dsl.get("name") or "Mainflow Case")
+    mainflow_tag = infer_mainflow_tag(case)
+    project_id = case.get("project_id") or metadata.get("project_id") or 1
+
+    dsl["name"] = str(dsl.get("name") or case_name)
+    dsl["description"] = dsl.get("description") or case.get("description")
+    dsl["tags"] = [mainflow_tag]
+    dsl["steps"] = normalize_steps(list(dsl.get("steps") or []))
+
+    normalized = {
+        "project_id": int(project_id),
+        "name": case_name,
+        "description": case.get("description"),
+        "tags": [mainflow_tag],
+        "dsl_json": dsl,
+    }
+    return clean_empty(normalized), evidence
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="legacy raw case payload JSON")
+    parser.add_argument("--output", required=True, help="case-import-payloads.json")
+    args = parser.parse_args()
+
+    draft_path = Path(args.input)
+    payload = load_payload(draft_path)
+    metadata = dict(payload.get("metadata") or {})
+    evidence_by_case: dict[str, list[dict[str, Any]]] = {}
+    cases: list[dict[str, Any]] = []
+
+    for case in payload["cases"]:
+        normalized, evidence = normalize_case(case, metadata)
+        cases.append(normalized)
+        evidence_by_case[normalized["name"]] = evidence
+
+    output_payload = {
+        "metadata": {
+            **metadata,
+            "normalized_at": datetime.now(timezone.utc).isoformat(),
+            "generated_by": metadata.get("generated_by") or "workflow-generate-mainflow-cases",
+            "case_evidence": evidence_by_case,
+        },
+        "cases": cases,
+    }
+
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(output_payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"output": str(output), "case_count": len(cases)}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())