@aipper/aiws-spec 0.0.1

package/templates/workspace/tools/install_iflow_watchdog_systemd_user.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+die() { echo "error: $*" >&2; exit 2; }
+have() { command -v "$1" >/dev/null 2>&1; }
+
+usage() {
+  cat <<'EOF'
+Usage:
+  bash tools/install_iflow_watchdog_systemd_user.sh
+  bash tools/install_iflow_watchdog_systemd_user.sh --name <instance>
+  bash tools/install_iflow_watchdog_systemd_user.sh --workspace <abs_path>
+  bash tools/install_iflow_watchdog_systemd_user.sh --name <instance> --workspace <abs_path>
+
+What it does:
+  - Installs systemd user instance units:
+      ~/.config/systemd/user/iflow-watchdog@.service
+      ~/.config/systemd/user/iflow-watchdog@.timer
+  - Writes per-instance env file:
+      ~/.config/iflow-watchdog/<instance>.env
+  - Enables and starts the timer:
+      systemctl --user enable --now iflow-watchdog@<instance>.timer
+
+Notes:
+  - You can run multiple instances on one server (different --name and --workspace).
+  - Unattended mode uses --yolo; only use in test environment.
+Defaults:
+  - --workspace defaults to current directory (pwd)
+  - --name defaults to basename(--workspace)
+EOF
+}
+
+name=""
+workspace=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --name) name="${2:-}"; shift 2 ;;
+    --workspace) workspace="${2:-}"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) die "unknown arg: $1" ;;
+  esac
+done
+
+if [[ -z "$workspace" ]]; then
+  workspace="$(pwd)"
+fi
+
+if [[ -z "$name" ]]; then
+  name="$(basename "$workspace")"
+fi
+
+[[ "$workspace" == /* ]] || die "--workspace must be an absolute path"
+[[ -d "$workspace" ]] || die "workspace not found: $workspace"
+
+have systemctl || die "missing: systemctl"
+
+if [[ ! -f "$workspace/AI_WORKSPACE.md" ]] || [[ ! -f "$workspace/REQUIREMENTS.md" ]]; then
+  die "workspace must contain AI_WORKSPACE.md and REQUIREMENTS.md: $workspace"
+fi
+
+# Best-effort check that systemd --user is available (common pitfall on servers).
+if [[ -z "${XDG_RUNTIME_DIR:-}" ]] || ! systemctl --user is-system-running >/dev/null 2>&1; then
+  die "systemd --user not running (try: loginctl enable-linger $USER, then re-login)"
+fi
+
+unit_dir="$HOME/.config/systemd/user"
+env_dir="$HOME/.config/iflow-watchdog"
+mkdir -p "$unit_dir" "$env_dir"
+
+src_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+tpl_service="$src_dir/systemd/iflow-watchdog@.service"
+tpl_timer="$src_dir/systemd/iflow-watchdog@.timer"
+[[ -f "$tpl_service" ]] || die "missing template: $tpl_service"
+[[ -f "$tpl_timer" ]] || die "missing template: $tpl_timer"
+
+cp -a "$tpl_service" "$unit_dir/iflow-watchdog@.service"
+cp -a "$tpl_timer" "$unit_dir/iflow-watchdog@.timer"
+
+env_file="$env_dir/${name}.env"
+
+# Only allow unattended --yolo if AI_WORKSPACE.md declares test environment.
+yo="0"
+if grep -Eq '^\s*-\s*environment\s*:\s*"?test"?\s*$' "$workspace/AI_WORKSPACE.md"; then
+  yo="1"
+fi
+
+cat >"$env_file" <<EOF
+# Generated by tools/install_iflow_watchdog_systemd_user.sh
+WORKSPACE_DIR=${workspace}
+IFLOW_WATCHDOG_ROOT=.
+# Unattended mode (uses iflow --yolo). Only safe when environment=test.
+IFLOW_WATCHDOG_YOLO=${yo}
+# Optional: override logs dir (default: <workspace>/.agentdocs/tmp/server-test)
+# IFLOW_WATCHDOG_LOG_DIR=${workspace}/.agentdocs/tmp/server-test
+IFLOW_DRAIN_MAX_ENDPOINTS=30
+IFLOW_WATCHDOG_SLEEP_S=10
+EOF
+
+systemctl --user daemon-reload
+
+if [[ "$yo" == "1" ]]; then
+  systemctl --user enable --now "iflow-watchdog@${name}.timer"
+  enabled_msg="enabled"
+else
+  enabled_msg="not enabled (edit IFLOW_WATCHDOG_YOLO=1 after confirming test env)"
+fi
+
+echo "OK: installed iflow-watchdog@${name}"
+echo "env:  $env_file"
+echo "unit: $unit_dir/iflow-watchdog@.service"
+echo "timer: iflow-watchdog@${name}.timer ($enabled_msg)"
+echo "tune: edit $env_file, then run:"
+echo "  systemctl --user daemon-reload"
+echo "  systemctl --user restart iflow-watchdog@${name}.service"
+if [[ "$yo" != "1" ]]; then
+  echo "enable:"
+  echo "  systemctl --user enable --now iflow-watchdog@${name}.timer"
+fi

package/templates/workspace/tools/requirements_contract.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+COLUMNS = [
+    "Req_ID",
+    "Title",
+    "Change_Type",
+    "Module",
+    "CRUD",
+    "Actor",
+    "Scenario",
+    "Preconditions",
+    "Inputs",
+    "Outputs",
+    "Data_Model",
+    "Business_Logic",
+    "API_Impact",
+    "NonFunctional",
+    "Spec_Status",
+    "Impl_Status",
+    "Tests",
+    "Evidence",
+    "Owner",
+    "Created_At",
+    "Updated_At",
+    "Notes",
+]
+
+
+SPEC_STATUS = {"DRAFT", "READY"}
+IMPL_STATUS = {"TODO", "DOING", "DONE", "BLOCKED", "SKIP"}
+CHANGE_TYPE = {"ADD", "UPDATE", "DELETE", "CLARIFY"}
+
+
+def now_utc() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def read_rows(path: Path) -> List[Dict[str, str]]:
+    if not path.exists():
+        return []
+    with path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        rows: List[Dict[str, str]] = []
+        for r in reader:
+            rows.append({k: (r.get(k) or "") for k in COLUMNS})
+        return rows
+
+
+def write_rows(path: Path, rows: List[Dict[str, str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=COLUMNS)
+        writer.writeheader()
+        for r in rows:
+            writer.writerow({k: (r.get(k) or "") for k in COLUMNS})
+
+
+def ensure_header(path: Path) -> None:
+    if path.exists():
+        with path.open("r", encoding="utf-8", newline="") as f:
+            first = f.readline()
+        if first.strip().split(",")[:3] == ["Req_ID", "Title", "Change_Type"]:
+            return
+    write_rows(path, [])
+
+
+def next_req_id(rows: List[Dict[str, str]]) -> str:
+    max_n = 0
+    for r in rows:
+        rid = (r.get("Req_ID") or "").strip()
+        if rid.startswith("REQ-") and rid[4:].isdigit():
+            max_n = max(max_n, int(rid[4:]))
+    return f"REQ-{max_n+1:04d}"
+
+
+def normalize_choice(value: str, allowed: set[str], field: str) -> str:
+    v = value.strip().upper()
+    if v and v not in allowed:
+        raise SystemExit(f"invalid {field}: {value!r}, allowed: {sorted(allowed)}")
+    return v
+
+
+def add_row(
+    *,
+    path: Path,
+    title: str,
+    change_type: str,
+    module: str,
+    crud: str,
+    actor: str,
+    owner: str,
+    spec_status: str,
+    impl_status: str,
+) -> str:
+    rows = read_rows(path)
+    rid = next_req_id(rows)
+    ts = now_utc()
+    rows.append(
+        {
+            "Req_ID": rid,
+            "Title": title.strip(),
+            "Change_Type": normalize_choice(change_type, CHANGE_TYPE, "Change_Type") or "ADD",
+            "Module": module.strip(),
+            "CRUD": crud.strip(),
+            "Actor": actor.strip(),
+            "Scenario": "",
+            "Preconditions": "",
+            "Inputs": "",
+            "Outputs": "",
+            "Data_Model": "",
+            "Business_Logic": "",
+            "API_Impact": "",
+            "NonFunctional": "",
+            "Spec_Status": normalize_choice(spec_status, SPEC_STATUS, "Spec_Status") or "DRAFT",
+            "Impl_Status": normalize_choice(impl_status, IMPL_STATUS, "Impl_Status") or "TODO",
+            "Tests": "",
+            "Evidence": "",
+            "Owner": owner.strip(),
+            "Created_At": ts,
+            "Updated_At": ts,
+            "Notes": "",
+        }
+    )
+    write_rows(path, rows)
+    return rid
+
+
+def set_fields(*, path: Path, req_id: str, updates: Dict[str, str]) -> None:
+    rows = read_rows(path)
+    found = False
+    ts = now_utc()
+    for r in rows:
+        if (r.get("Req_ID") or "").strip() == req_id:
+            found = True
+            for k, v in updates.items():
+                if k not in COLUMNS:
+                    raise SystemExit(f"unknown column: {k}")
+                r[k] = v
+            r["Updated_At"] = ts
+            break
+    if not found:
+        raise SystemExit(f"Req_ID not found: {req_id}")
+    write_rows(path, rows)
+
+
+@dataclass(frozen=True)
+class ValidateProblem:
+    req_id: str
+    field: str
+    message: str
+
+
+def validate_rows(rows: List[Dict[str, str]]) -> List[ValidateProblem]:
+    problems: List[ValidateProblem] = []
+    for r in rows:
+        rid = (r.get("Req_ID") or "").strip()
+        if not rid or rid == "REQ-000":
+            continue
+        spec = (r.get("Spec_Status") or "").strip().upper()
+        impl = (r.get("Impl_Status") or "").strip().upper()
+        if spec and spec not in SPEC_STATUS:
+            problems.append(ValidateProblem(rid, "Spec_Status", f"invalid value: {spec}"))
+        if impl and impl not in IMPL_STATUS:
+            problems.append(ValidateProblem(rid, "Impl_Status", f"invalid value: {impl}"))
+        ctype = (r.get("Change_Type") or "").strip().upper()
+        if ctype and ctype not in CHANGE_TYPE:
+            problems.append(ValidateProblem(rid, "Change_Type", f"invalid value: {ctype}"))
+
+        if spec == "READY":
+            required = [
+                "Title",
+                "Module",
+                "CRUD",
+                "Scenario",
+                "Inputs",
+                "Outputs",
+                "Business_Logic",
+                "Tests",
+            ]
+            for f in required:
+                if not (r.get(f) or "").strip():
+                    problems.append(ValidateProblem(rid, f, "required when Spec_Status=READY"))
+        if impl == "DONE":
+            for f in ["Evidence"]:
+                if not (r.get(f) or "").strip():
+                    problems.append(ValidateProblem(rid, f, "required when Impl_Status=DONE"))
+    return problems
+
+
+def main(argv: List[str]) -> int:
+    p = argparse.ArgumentParser(description="Manage requirements execution contract CSV (requirements/requirements-issues.csv).")
+    p.add_argument("--workspace", default=".", help="workspace root")
+    p.add_argument("--csv", default="requirements/requirements-issues.csv", help="contract CSV path (relative to workspace)")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("init", help="create CSV with header if missing")
+
+    add = sub.add_parser("add", help="append a new requirement row (DRAFT by default)")
+    add.add_argument("--title", required=True)
+    add.add_argument("--change-type", default="ADD")
+    add.add_argument("--module", default="")
+    add.add_argument("--crud", default="")
+    add.add_argument("--actor", default="")
+    add.add_argument("--owner", default="")
+    add.add_argument("--spec-status", default="DRAFT")
+    add.add_argument("--impl-status", default="TODO")
+
+    setp = sub.add_parser("set", help="update fields for a given Req_ID")
+    setp.add_argument("req_id")
+    setp.add_argument("--field", action="append", default=[], help="key=value (repeatable)")
+
+    sub.add_parser("validate", help="validate READY/DONE requirements for completeness")
+
+    args = p.parse_args(argv)
+    root = Path(args.workspace).resolve()
+    csv_path = (root / args.csv).resolve()
+
+    if args.cmd == "init":
+        ensure_header(csv_path)
+        print(f"OK: ensured {csv_path.relative_to(root)}")
+        return 0
+
+    ensure_header(csv_path)
+
+    if args.cmd == "add":
+        rid = add_row(
+            path=csv_path,
+            title=args.title,
+            change_type=args.change_type,
+            module=args.module,
+            crud=args.crud,
+            actor=args.actor,
+            owner=args.owner,
+            spec_status=args.spec_status,
+            impl_status=args.impl_status,
+        )
+        print(f"OK: added {rid} -> {csv_path.relative_to(root)}")
+        return 0
+
+    if args.cmd == "set":
+        updates: Dict[str, str] = {}
+        for kv in args.field:
+            if "=" not in kv:
+                raise SystemExit(f"invalid --field: {kv!r}, expected key=value")
+            k, v = kv.split("=", 1)
+            updates[k] = v
+        if "Spec_Status" in updates:
+            updates["Spec_Status"] = normalize_choice(updates["Spec_Status"], SPEC_STATUS, "Spec_Status")
+        if "Impl_Status" in updates:
+            updates["Impl_Status"] = normalize_choice(updates["Impl_Status"], IMPL_STATUS, "Impl_Status")
+        if "Change_Type" in updates:
+            updates["Change_Type"] = normalize_choice(updates["Change_Type"], CHANGE_TYPE, "Change_Type")
+        set_fields(path=csv_path, req_id=args.req_id, updates=updates)
+        print(f"OK: updated {args.req_id} -> {csv_path.relative_to(root)}")
+        return 0
+
+    if args.cmd == "validate":
+        rows = read_rows(csv_path)
+        problems = validate_rows(rows)
+        if not problems:
+            print(f"OK: contract validated ({csv_path.relative_to(root)})")
+            return 0
+        print(f"ERROR: contract validation failed ({csv_path.relative_to(root)})", file=sys.stderr)
+        for pr in problems[:80]:
+            print(f"- {pr.req_id}: {pr.field}: {pr.message}", file=sys.stderr)
+        if len(problems) > 80:
+            print(f"... and {len(problems)-80} more", file=sys.stderr)
+        return 2
+
+    raise SystemExit("unreachable")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
+

package/templates/workspace/tools/requirements_contract_sync.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+FLOW_SPEC_BEGIN = "<!-- FLOW_SPEC_BEGIN -->"
+FLOW_SPEC_END = "<!-- FLOW_SPEC_END -->"
+
+
+COLUMNS = [
+    "Req_ID",
+    "Title",
+    "Change_Type",
+    "Module",
+    "CRUD",
+    "Actor",
+    "Scenario",
+    "Preconditions",
+    "Inputs",
+    "Outputs",
+    "Data_Model",
+    "Business_Logic",
+    "API_Impact",
+    "NonFunctional",
+    "Spec_Status",
+    "Impl_Status",
+    "Tests",
+    "Evidence",
+    "Owner",
+    "Created_At",
+    "Updated_At",
+    "Notes",
+]
+
+
+def _now_utc() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def _read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8", errors="replace")
+
+
+def extract_flow_spec_json(requirements_text: str) -> Dict[str, Any]:
+    if FLOW_SPEC_BEGIN not in requirements_text or FLOW_SPEC_END not in requirements_text:
+        return {}
+    body = requirements_text.split(FLOW_SPEC_BEGIN, 1)[1].split(FLOW_SPEC_END, 1)[0]
+    start = body.find("```")
+    if start == -1:
+        return {}
+    fence = body[start:]
+    lines = fence.splitlines()
+    if not lines:
+        return {}
+    header = lines[0].strip().lower()
+    if not header.startswith("```") or "json" not in header:
+        return {}
+    payload_lines: List[str] = []
+    for ln in lines[1:]:
+        if ln.strip().startswith("```"):
+            break
+        payload_lines.append(ln)
+    raw = "\n".join(payload_lines).strip()
+    if not raw:
+        return {}
+    data = json.loads(raw)
+    if not isinstance(data, dict):
+        return {}
+    return data
+
+
+@dataclass(frozen=True)
+class FlowStep:
+    method: str
+    path: str
+    name: str = ""
+
+
+@dataclass(frozen=True)
+class Flow:
+    flow_id: str
+    title: str
+    steps: List[FlowStep]
+    notes: str = ""
+
+
+def parse_flows(data: Dict[str, Any]) -> List[Flow]:
+    flows_raw = data.get("flows")
+    if not isinstance(flows_raw, list):
+        return []
+    out: List[Flow] = []
+    for item in flows_raw:
+        if not isinstance(item, dict):
+            continue
+        flow_id = str(item.get("id") or "").strip()
+        if not flow_id:
+            continue
+        title = str(item.get("title") or flow_id).strip()
+        notes = str(item.get("notes") or "").strip()
+        steps_raw = item.get("steps") or []
+        if not isinstance(steps_raw, list):
+            continue
+        steps: List[FlowStep] = []
+        for s in steps_raw:
+            if not isinstance(s, dict):
+                continue
+            method = str(s.get("method") or "GET").strip().upper()
+            path = str(s.get("path") or "").strip()
+            name = str(s.get("name") or "").strip()
+            if not path:
+                continue
+            steps.append(FlowStep(method=method, path=path, name=name))
+        if steps:
+            out.append(Flow(flow_id=flow_id, title=title, steps=steps, notes=notes))
+    return out
+
+
+def _read_csv_rows(path: Path) -> List[Dict[str, str]]:
+    if not path.exists():
+        return []
+    with path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        rows: List[Dict[str, str]] = []
+        for r in reader:
+            rows.append({k: (r.get(k) or "") for k in COLUMNS})
+        return rows
+
+
+def _write_csv_rows(path: Path, rows: List[Dict[str, str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=COLUMNS)
+        writer.writeheader()
+        for r in rows:
+            writer.writerow({k: (r.get(k) or "") for k in COLUMNS})
+
+
+def _ensure_header(path: Path) -> None:
+    if path.exists():
+        with path.open("r", encoding="utf-8", newline="") as f:
+            first = f.readline().strip()
+        if first.split(",")[:3] == ["Req_ID", "Title", "Change_Type"]:
+            return
+    _write_csv_rows(path, [])
+
+
+def _next_req_id(rows: List[Dict[str, str]]) -> str:
+    max_n = 0
+    for r in rows:
+        rid = (r.get("Req_ID") or "").strip()
+        if rid.startswith("REQ-") and rid[4:].isdigit():
+            max_n = max(max_n, int(rid[4:]))
+    return f"REQ-{max_n+1:04d}"
+
+
+def _find_row_by_source(rows: List[Dict[str, str]], source: str) -> Optional[Dict[str, str]]:
+    needle = f"source={source}"
+    for r in rows:
+        notes = (r.get("Notes") or "").strip()
+        if needle in notes:
+            return r
+    return None
+
+
+def _append_source(notes: str, source: str) -> str:
+    token = f"source={source}"
+    s = (notes or "").strip()
+    if token in s:
+        return s
+    return (s + ("\n" if s else "") + token).strip()
+
+
+def upsert_from_flows(
+    *,
+    csv_path: Path,
+    flows: List[Flow],
+    default_owner: str,
+    default_tests: str,
+) -> Dict[str, int]:
+    _ensure_header(csv_path)
+    rows = _read_csv_rows(csv_path)
+    now = _now_utc()
+
+    created = 0
+    updated = 0
+
+    for flow in flows:
+        source = f"flow:{flow.flow_id}"
+        row = _find_row_by_source(rows, source)
+        steps_str = " -> ".join([f"{s.method} {s.path}".strip() for s in flow.steps])
+        if row is None:
+            rid = _next_req_id(rows)
+            rows.append(
+                {
+                    "Req_ID": rid,
+                    "Title": flow.title,
+                    "Change_Type": "CLARIFY",
+                    "Module": "",
+                    "CRUD": "",
+                    "Actor": "",
+                    "Scenario": flow.title,
+                    "Preconditions": "",
+                    "Inputs": "",
+                    "Outputs": "",
+                    "Data_Model": "",
+                    "Business_Logic": flow.notes,
+                    "API_Impact": steps_str,
+                    "NonFunctional": "",
+                    "Spec_Status": "DRAFT",
+                    "Impl_Status": "TODO",
+                    "Tests": default_tests,
+                    "Evidence": "",
+                    "Owner": default_owner,
+                    "Created_At": now,
+                    "Updated_At": now,
+                    "Notes": _append_source("", source),
+                }
+            )
+            created += 1
+        else:
+            row["Title"] = (row.get("Title") or "").strip() or flow.title
+            row["Scenario"] = (row.get("Scenario") or "").strip() or flow.title
+            row["Business_Logic"] = (row.get("Business_Logic") or "").strip() or flow.notes
+            row["API_Impact"] = (row.get("API_Impact") or "").strip() or steps_str
+            row["Tests"] = (row.get("Tests") or "").strip() or default_tests
+            row["Owner"] = (row.get("Owner") or "").strip() or default_owner
+            row["Notes"] = _append_source(row.get("Notes") or "", source)
+            row["Updated_At"] = now
+            updated += 1
+
+    _write_csv_rows(csv_path, rows)
+    return {"created": created, "updated": updated, "total_flows": len(flows)}
+
+
+def main(argv: List[str]) -> int:
+    p = argparse.ArgumentParser(description="Backfill requirements contract CSV from REQUIREMENTS.md FlowSpec.")
+    p.add_argument("--workspace", default=".", help="workspace root")
+    p.add_argument("--requirements", default="REQUIREMENTS.md", help="requirements markdown path (relative to workspace)")
+    p.add_argument("--out-csv", default="requirements/requirements-issues.csv", help="output contract CSV path")
+    p.add_argument("--owner", default="", help="default Owner for new rows")
+    p.add_argument(
+        "--default-tests",
+        default="",
+        help="default Tests for new rows (leave empty to force manual fill later)",
+    )
+    args = p.parse_args(argv)
+
+    root = Path(args.workspace).resolve()
+    req_path = (root / args.requirements).resolve()
+    csv_path = (root / args.out_csv).resolve()
+
+    if not req_path.exists():
+        raise SystemExit(f"missing requirements file: {req_path}")
+
+    spec = extract_flow_spec_json(_read_text(req_path))
+    flows = parse_flows(spec) if spec else []
+    if not flows:
+        print("WARN: no FlowSpec found in REQUIREMENTS.md (or flows empty); nothing to sync.")
+        print("hint: add/update FlowSpec between FLOW_SPEC markers, then re-run.")
+        _ensure_header(csv_path)
+        print(f"OK: ensured {csv_path.relative_to(root)}")
+        return 0
+
+    default_owner = args.owner.strip()
+    default_tests = args.default_tests.strip()
+    stats = upsert_from_flows(
+        csv_path=csv_path,
+        flows=flows,
+        default_owner=default_owner,
+        default_tests=default_tests,
+    )
+
+    print(f"OK: synced from FlowSpec -> {csv_path.relative_to(root)}")
+    print(f"- flows: {stats['total_flows']}")
+    print(f"- created: {stats['created']}")
+    print(f"- updated: {stats['updated']}")
+    print("next: fill missing fields, then run: python3 tools/requirements_contract.py validate")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(__import__('sys').argv[1:]))
+