aw-spec-cli 0.1.7 → 0.1.9

package/assets/.appweaver/scripts/powershell/aw-xref.ps1

@@ -0,0 +1,15 @@
+# aw-xref.ps1 — thin wrapper: delegate to the single python core.
+#
+# Cross-reference (OKF dependency) substrate. Logic lives ONCE in
+# ..\python\aw-xref.py; this wrapper exists only so the orchestrator's
+# execute_script (sh:/ps1: dispatch) can invoke it. Args pass through.
+#
+#   aw-xref.ps1 record         --using X --design <design.md> [--origin ...] [--date YYYY-MM-DD] [--root DIR]
+#   aw-xref.ps1 list           --aggregate Y [--root DIR] [--bundle knowledge]
+#   aw-xref.ps1 concept-upsert   --aggregate X [--source-files a,b,c] [--description D] [--origin ...] [--root DIR]
+#   aw-xref.ps1 concept-overview --aggregate X (--text PROSE | --text-file F) [--root DIR]
+#   aw-xref.ps1 concept-paths    --aggregate X | --feature-dir <dir> [--root DIR] [--bundle knowledge]
+$ErrorActionPreference = "Stop"
+$core = Join-Path $PSScriptRoot "..\python\aw-xref.py"
+& python3 $core @args
+exit $LASTEXITCODE

package/assets/.appweaver/scripts/python/aw-component-catalog.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+aw-component-catalog — the component implementation catalog's deterministic parser.
+
+Backs the `component-catalog` aw-spec-actions subcommand, called identically by the
+bash and the powershell twin so the two stay in parity by construction rather than by
+review.
+
+`add-component` needs the list of implementations a component offers before it can ask
+which one(s) to wire. That list is a markdown table in the component's own
+integration.md runbook — under the heading whose text carries "implementation catalog"
+or "selection list" — so the runbook stays the single authority a human and an agent
+both read, and no second machine-readable manifest can fall out of step with it.
+
+The parse is deliberately forgiving about the table's SHAPE and strict about its KEY:
+the `Key` column may sit at any position (the first column is assumed when no header
+cell is literally "key"), any other column becomes part of the description prefixed by
+its own header, and a component whose runbook carries no such table simply reports
+integrable=false rather than failing — `add-component` then wires it without asking.
+
+Stdlib only. Emits one line of compact JSON on stdout:
+
+    {"integrable": bool, "impl_keys": [str], "implementations": [{"key","desc"}]}
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+
+HEADING_RE = re.compile(r"^#{1,6}\s")
+CATALOG_RE = re.compile(r"(?i)implementation catalog|selection list")
+SEPARATOR_RE = re.compile(r":?-{2,}:?")
+
+
+def emit(obj):
+    sys.stdout.write(json.dumps(obj, separators=(",", ":")) + "\n")
+
+
+def cells(row):
+    """Split one markdown table row into its trimmed cells."""
+    return [c.strip() for c in row.strip().strip("|").split("|")]
+
+
+def catalog_rows(lines):
+    """The contiguous run of table rows under the catalog heading; [] when absent."""
+    start = None
+    for i, ln in enumerate(lines):
+        if HEADING_RE.match(ln) and CATALOG_RE.search(ln):
+            start = i + 1
+            break
+    if start is None:
+        return []
+    rows = []
+    for ln in lines[start:]:
+        if HEADING_RE.match(ln):      # the next heading ends the section
+            break
+        s = ln.strip()
+        if s.startswith("|"):
+            rows.append(s)
+        elif rows:                    # a blank or non-table line after the table ends it
+            break
+    return rows
+
+
+def parse(rows):
+    impl_keys, implementations = [], []
+    if len(rows) < 2:
+        return impl_keys, implementations
+    header = cells(rows[0])
+    kidx = 0
+    for j, h in enumerate(header):
+        if h.strip().lower() == "key":
+            kidx = j
+            break
+    for row in rows[2:]:              # skip the header and its separator
+        c = cells(row)
+        if not c or all(SEPARATOR_RE.fullmatch(x or "") for x in c):
+            continue
+        if kidx >= len(c):
+            continue
+        key = c[kidx].strip("` ").strip()
+        if not key:
+            continue
+        parts = []
+        for j, val in enumerate(c):
+            if j == kidx or not val:
+                continue
+            h = header[j] if j < len(header) else ""
+            parts.append("%s: %s" % (h, val) if h else val)
+        impl_keys.append(key)
+        implementations.append({"key": key, "desc": " · ".join(parts)})
+    return impl_keys, implementations
+
+
+def main():
+    ap = argparse.ArgumentParser(prog="aw-component-catalog", description=__doc__)
+    ap.add_argument("--repo", default=".",
+                    help="repository root (callers pass their own resolver's answer)")
+    ap.add_argument("--file", required=True,
+                    help="the component's integration.md, absolute or repo-relative")
+    args = ap.parse_args()
+
+    path = args.file
+    if not os.path.isabs(path):
+        path = os.path.join(args.repo, path)
+    if not os.path.exists(path):
+        emit({"integrable": False, "impl_keys": [], "implementations": []})
+        return
+
+    with open(path, encoding="utf-8") as fh:
+        lines = fh.read().splitlines()
+    impl_keys, implementations = parse(catalog_rows(lines))
+    emit({"integrable": len(impl_keys) > 0,
+          "impl_keys": impl_keys,
+          "implementations": implementations})
+
+
+if __name__ == "__main__":
+    main()