@event4u/agent-config 6.0.0 → 7.0.0

package/src/scripts/new_skill.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""Interactive scaffolder for new skills under the packages/ layout.
-
-Phase 4.5 of the monorepo migration (ADR-017). Asks for pack, type,
-name, workspaces, and description, then drops a templated artefact
-into ``packages/<pack-dir>/.agent-src.uncondensed/<type>s/<name>/SKILL.md``.
-
-Type → directory mapping:
-  - skill    → skills/<name>/SKILL.md
-  - rule     → rules/<name>.md
-  - command  → commands/<name>.md
-
-CLI (non-interactive overrides):
-  --pack PACK         pack id (e.g. ``laravel`` or ``core``)
-  --type TYPE         skill | rule | command (default: skill)
-  --name NAME         artefact slug (kebab-case)
-  --description TEXT  one-line description (trigger phrasing)
-  --workspace WS      repeatable; defaults to pack's owner list
-  --force             overwrite if file exists
-"""
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-ROOT = Path(__file__).resolve().parents[2]
-PACKAGES = ROOT / "packages"
-PACKS_VOCAB = ROOT / "src" / "config" / "discovery" / "packs.yml"
-
-TEMPLATES = {
-    "skill": "skills/{name}/SKILL.md",
-    "rule": "rules/{name}.md",
-    "command": "commands/{name}.md",
-}
-
-
-def _load_vocab() -> dict[str, dict[str, Any]]:
-    if not PACKS_VOCAB.exists():
-        return {}
-    data = yaml.safe_load(PACKS_VOCAB.read_text(encoding="utf-8")) or []
-    return {p["id"]: p for p in data}
-
-
-def _list_packs() -> list[str]:
-    if not PACKAGES.exists():
-        return []
-    return sorted([
-        ("core" if p.name == "core" else p.name.removeprefix("pack-"))
-        for p in PACKAGES.iterdir() if p.is_dir()
-    ])
-
-
-def _pack_dir(pack_id: str) -> Path:
-    return PACKAGES / ("core" if pack_id == "core" else f"pack-{pack_id}")
-
-
-def _prompt(label: str, default: str | None = None, choices: list[str] | None = None) -> str:
-    suffix = f" [{default}]" if default else ""
-    if choices:
-        suffix = f" ({'/'.join(choices)})" + suffix
-    while True:
-        raw = input(f"{label}{suffix}: ").strip()
-        if not raw and default is not None:
-            return default
-        if choices and raw not in choices:
-            print(f"  must be one of: {', '.join(choices)}")
-            continue
-        if raw:
-            return raw
-
-
-def _frontmatter(name: str, description: str, workspaces: list[str], pack: str) -> str:
-    fm: dict[str, Any] = {
-        "name": name,
-        "description": description,
-        "source": "package",
-        "workspaces": workspaces,
-        "packs": [pack] if pack != "core" else [],
-        "lifecycle": "active",
-        "trust": {"level": "professional", "confidence": "medium", "human_review_required": False},
-        "install": {"default": False, "removable": True},
-    }
-    if not fm["packs"]:
-        del fm["packs"]
-    return "---\n" + yaml.safe_dump(fm, sort_keys=False, allow_unicode=True) + "---\n"
-
-
-def _body(kind: str, name: str, description: str) -> str:
-    if kind == "skill":
-        return (
-            f"\n# {name}\n\n## When to use\n\n{description}\n\n## Procedure\n\n"
-            "1. _TODO: replace with the real step-by-step._\n\n"
-            "## Examples\n\n_TODO: copy-pasteable example._\n"
-        )
-    if kind == "rule":
-        return f"\n# {name}\n\n{description}\n\n## Iron Law\n\n```\nTODO\n```\n"
-    return f"\n# {name}\n\n{description}\n\n## Steps\n\n1. _TODO_\n"
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--pack")
-    ap.add_argument("--type", dest="kind", choices=list(TEMPLATES))
-    ap.add_argument("--name")
-    ap.add_argument("--description")
-    ap.add_argument("--workspace", action="append", default=[])
-    ap.add_argument("--force", action="store_true")
-    args = ap.parse_args()
-
-    packs = _list_packs()
-    if not packs:
-        print("error: no packages/ tree found", file=sys.stderr)
-        return 2
-    vocab = _load_vocab()
-    interactive = sys.stdin.isatty()
-    pack = args.pack or (_prompt("pack", default="core", choices=packs) if interactive else "core")
-    if pack not in packs:
-        print(f"error: pack '{pack}' not in {packs}", file=sys.stderr)
-        return 2
-    kind = args.kind or (_prompt("type", default="skill", choices=list(TEMPLATES)) if interactive else "skill")
-    name = args.name or (_prompt("name (kebab-case)") if interactive else "")
-    if not name or " " in name or name != name.lower():
-        print(f"error: name '{name}' must be lowercase kebab-case", file=sys.stderr)
-        return 2
-    description = args.description or (_prompt("description (one line)") if interactive else "TODO: describe trigger")
-    workspaces = args.workspace or vocab.get(pack, {}).get("workspaces") or ["engineering"]
-
-    rel = TEMPLATES[kind].format(name=name)
-    out = _pack_dir(pack) / ".agent-src.uncondensed" / rel
-    if out.exists() and not args.force:
-        print(f"error: {out.relative_to(ROOT)} exists (use --force)", file=sys.stderr)
-        return 1
-    out.parent.mkdir(parents=True, exist_ok=True)
-    out.write_text(_frontmatter(name, description, workspaces, pack) + _body(kind, name, description), encoding="utf-8")
-    print(f"created: {out.relative_to(ROOT)}")
-    print("next steps:")
-    print("  1. flesh out the body")
-    print("  2. run `task sync` to project into dist/agent-src/ and .augment/")
-    print("  3. run `task lint-skills` for validation")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/onboarding_gate_hook.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-"""Platform-agnostic hook for the `onboarding-gate` rule.
-
-Reads `.agent-settings.yml` from the consumer repo and writes a
-deterministic state file the rule body can cite as the source of
-truth for "do I need to prompt the user about /onboard?".
-
-Output is written to `agents/runtime/state/onboarding-gate.json` with:
-  {
-    "required": <bool>,         // true → rule fires on first turn
-    "reason":   "<string>",     // why this state was set
-    "checked_at": "<iso8601>",  // last hook run
-    "settings_present": <bool>  // .agent-settings.yml exists
-  }
-
-Exit code is **always 0**. Hooks must never block the agent loop.
-
-Output discipline:
-  - stdout: nothing (Augment surfaces stdout to the user)
-  - stderr: one short line in --verbose mode, otherwise silent
-
-CLI:
-  python3 scripts/onboarding_gate_hook.py [--platform NAME] [--verbose]
-"""
-from __future__ import annotations
-
-import argparse
-import datetime as _dt
-import re
-import sys
-from pathlib import Path
-
-# Re-use the shared atomic-write helper so concerns honour the single
-# `agents/runtime/state/.dispatcher.lock` discipline (hook-architecture-v1.md
-# § Concurrency, Phase 7.4).
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from hooks.state_io import atomic_write_json  # noqa: E402
-
-SETTINGS_FILE = ".agent-settings.yml"
-STATE_DIR = Path("agents") / "state"
-STATE_FILE = STATE_DIR / "onboarding-gate.json"
-
-
-def _read_onboarded(settings_path: Path) -> tuple[bool, str]:
-    """Return (required, reason) — minimal, dependency-free YAML parsing.
-
-    We only need a single key under the `onboarding:` block. Full YAML is
-    overkill (and would pull in a runtime dep). We scan line-by-line for
-    `onboarded: <bool>` inside the `onboarding:` section.
-    """
-    if not settings_path.is_file():
-        return (False, "settings_file_missing")  # legacy: do not block
-
-    try:
-        text = settings_path.read_text(encoding="utf-8")
-    except OSError:
-        return (False, "settings_file_unreadable")
-
-    in_onboarding = False
-    onboarded_value: str | None = None
-    for raw in text.splitlines():
-        line = raw.rstrip()
-        if not line or line.lstrip().startswith("#"):
-            continue
-        if re.match(r"^onboarding\s*:\s*$", line):
-            in_onboarding = True
-            continue
-        if in_onboarding:
-            # Section ends when a top-level (non-indented) key starts.
-            if line and not line.startswith((" ", "\t")):
-                break
-            m = re.match(r"^\s+onboarded\s*:\s*(\S+)\s*(?:#.*)?$", line)
-            if m:
-                onboarded_value = m.group(1).strip().lower()
-
-    if onboarded_value is None:
-        return (False, "key_missing")  # legacy / pre-rule project
-    if onboarded_value in ("true", "yes", "on"):
-        return (False, "already_onboarded")
-    if onboarded_value in ("false", "no", "off"):
-        return (True, "explicit_false")
-    return (False, f"unknown_value:{onboarded_value}")
-
-
-def _write_state(consumer_root: Path, required: bool, reason: str,
-                 settings_present: bool) -> None:
-    """Write `agents/runtime/state/onboarding-gate.json` atomically.
-
-    Uses the shared `agents/runtime/state/.dispatcher.lock` so concurrent
-    dispatcher invocations across platforms cannot tear the file
-    (hook-architecture-v1.md § Concurrency, Phase 7.4).
-    """
-    payload = {
-        "required": required,
-        "reason": reason,
-        "checked_at": _dt.datetime.now(_dt.timezone.utc).isoformat(
-            timespec="seconds"),
-        "settings_present": settings_present,
-    }
-    atomic_write_json(consumer_root / STATE_FILE, payload)
-
-
-def run(*, consumer_root: Path, verbose: bool = False) -> int:
-    settings_path = consumer_root / SETTINGS_FILE
-    settings_present = settings_path.is_file()
-    try:
-        required, reason = _read_onboarded(settings_path)
-    except Exception:  # pragma: no cover — defensive
-        required, reason = (False, "hook_error")
-
-    try:
-        _write_state(consumer_root, required, reason, settings_present)
-    except OSError:
-        if verbose:
-            print("onboarding-gate-hook: state write failed",
-                  file=sys.stderr)
-        return 0  # never block
-
-    if verbose:
-        print(f"onboarding-gate-hook: required={required} reason={reason}",
-              file=sys.stderr)
-    return 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--platform", default="generic",
-                        help="informational platform tag")
-    parser.add_argument("--verbose", action="store_true",
-                        help="emit one stderr line per invocation")
-    args = parser.parse_args(argv)
-    # Drain stdin so callers piping JSON don't block on a SIGPIPE on
-    # platforms that strictly require stdin to be consumed.
-    try:
-        sys.stdin.read()
-    except Exception:
-        pass
-    return run(consumer_root=Path.cwd(), verbose=args.verbose)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

package/src/scripts/pack_mcp_content.py

@@ -1,293 +0,0 @@
-"""Pack agent-config content into a Worker-bundle JSON blob.
-
-Walks `dist/agent-src/skills/`, `dist/agent-src/commands/`, `dist/agent-src/rules/`,
-`docs/guidelines/`, `dist/agent-src/contexts/` via the same Python loaders
-that drive the local stdio kernel, emits one JSON blob and a sidecar
-manifest for `internal/workers/mcp/`.
-
-Outputs (relative to repo root):
-- `internal/workers/mcp/content.json`      — uncondensed, bundled by `wrangler deploy`.
-- `internal/workers/mcp/content.json.gz`   — gzipped archival copy for R2.
-- `internal/workers/mcp/manifest.json`     — manifest only (RCA / R2 sidecar).
-
-Hard-fail thresholds (Phase 2-5 council verdict D2):
-- Uncondensed JSON > 2 MB         → SystemExit(1).
-- Empty content (zero URIs)        → SystemExit(2). Catches a broken
-                                     `dist/agent-src/` tree before deploy.
-
-Cloud signature divergence vs local kernel (`metadata.compute_skill_set_signature`):
-- Local kernel:  SHA-256 over `(uri, mtime)` pairs — reproducible only
-                 within one filesystem.
-- This packer:   SHA-256 over `(uri, body)` pairs — reproducible across
-                 CI runs, machines, and re-clones. Same 12-char prefix.
-
-Governed by `docs/contracts/mcp-cloud-scope.md` §A0-cloud invariant 5.
-"""
-from __future__ import annotations
-
-import argparse
-import gzip
-import hashlib
-import json
-import os
-import subprocess
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-# Re-use the local kernel's loaders so the live-replay baseline stays
-# trivially comparable.
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from mcp_server.catalog import load_raw as load_tool_catalog_raw  # noqa: E402
-from mcp_server.prompts import scan_commands, scan_skills  # noqa: E402
-from mcp_server.resources import scan_contexts, scan_guidelines, scan_rules  # noqa: E402
-
-SCHEMA_VERSION = 1
-PACKER_VERSION = "1.0.0"
-# Worker bundle is the compact JSON; gzipped copy lives in R2. Cloudflare's
-# condensed-bundle limit is 3 MB (free) / 10 MB (paid); 778 KB gz today
-# (438 entries) leaves ample headroom. Hard-fail at 5 MB uncondensed so
-# the build dies before the Worker upload does.
-MAX_UNCONDENSED_BYTES = 5 * 1024 * 1024
-
-
-def _repo_root() -> Path:
-    # This file lives at src/scripts/pack_mcp_content.py — two parents up is
-    # src/, three is the repo root (broken parent count survived the
-    # scripts/ → src/scripts/ move and made pack() scan an empty tree).
-    return Path(__file__).resolve().parent.parent.parent
-
-
-def _git_sha(root: Path) -> str:
-    """Resolve HEAD SHA. Falls back to env var, then to all-zeros."""
-    for env_var in ("GITHUB_SHA", "CI_COMMIT_SHA", "GIT_COMMIT"):
-        sha = os.environ.get(env_var)
-        if sha and len(sha) >= 7:
-            return sha
-    try:
-        out = subprocess.run(
-            ["git", "rev-parse", "HEAD"],
-            cwd=root,
-            capture_output=True,
-            text=True,
-            check=True,
-            timeout=5,
-        )
-        return out.stdout.strip()
-    except (subprocess.SubprocessError, FileNotFoundError):
-        return "0" * 40
-
-
-def _package_version(root: Path) -> str:
-    data = json.loads((root / "package.json").read_text(encoding="utf-8"))
-    return str(data.get("version", "0.0.0"))
-
-
-def _collect_entries(root: Path) -> tuple[dict[str, dict[str, Any]], list[str]]:
-    """Run all 5 scanners and project entries into the wire shape."""
-    uris: dict[str, dict[str, Any]] = {}
-    errors: list[str] = []
-
-    skills, e = scan_skills(root)
-    errors.extend(e)
-    for s in skills:
-        key = f"skill://{s.name}"
-        uris[key] = {
-            "uri": key,
-            "name": s.name,
-            "description": s.description,
-            "body": s.body,
-            "source": s.source,
-            "kind": "skill",
-        }
-
-    commands, e = scan_commands(root)
-    errors.extend(e)
-    for c in commands:
-        # Command names are plain hyphen slugs since the 2026-06 Zed fix;
-        # the `: → .` rewrite stays only as a tolerance shim for stale trees.
-        key = f"command://{c.name.replace(':', '.')}"
-        uris[key] = {
-            "uri": key,
-            "name": c.name,
-            "description": c.description,
-            "body": c.body,
-            "source": c.source,
-            "kind": "command",
-        }
-
-    for scan in (scan_rules, scan_guidelines, scan_contexts):
-        items, e = scan(root)
-        errors.extend(e)
-        for r in items:
-            uris[r.uri] = {
-                "uri": r.uri,
-                "name": r.name,
-                "description": r.description,
-                "body": r.body,
-                "source": r.source,
-                "kind": r.kind,
-                "mime_type": r.mime_type,
-            }
-
-    return uris, errors
-
-
-def _content_signature(
-    uris: dict[str, dict[str, Any]],
-    tool_catalog: dict[str, Any],
-) -> tuple[str, str]:
-    """SHA-256 over sorted (uri, body) pairs plus the tool catalog JSON.
-
-    Returns (full_hex, 12-char prefix). The prefix is the wire-surface
-    `skillSetSignature`; the full hex is the diagnostic `content_hash_sha256`.
-    Including the catalog ensures a stub edit produces a new release_key.
-    """
-    hasher = hashlib.sha256()
-    for uri in sorted(uris):
-        hasher.update(uri.encode("utf-8"))
-        hasher.update(b"\x00")
-        hasher.update(uris[uri]["body"].encode("utf-8"))
-        hasher.update(b"\x1e")
-    hasher.update(b"\x1d")
-    hasher.update(
-        json.dumps(tool_catalog, ensure_ascii=False, sort_keys=True).encode("utf-8")
-    )
-    digest = hasher.hexdigest()
-    return digest, digest[:12]
-
-
-def _count_kinds(uris: dict[str, dict[str, Any]]) -> dict[str, int]:
-    counts = {"skill": 0, "command": 0, "rule": 0, "guideline": 0, "context": 0}
-    for entry in uris.values():
-        kind = entry["kind"]
-        if kind in counts:
-            counts[kind] += 1
-    return counts
-
-
-
-def _build_manifest(
-    *,
-    signature: str,
-    content_hash: str,
-    package_version: str,
-    git_sha: str,
-    built_at: str,
-    counts: dict[str, int],
-    tool_count: int,
-) -> dict[str, Any]:
-    short = git_sha[:7] if git_sha and git_sha != "0" * 40 else "unknown"
-    return {
-        "schema_version": SCHEMA_VERSION,
-        "signature": signature,
-        "content_hash_sha256": content_hash,
-        "package_version": package_version,
-        "release_key": f"v{package_version}-{short}",
-        "git_sha": git_sha,
-        "built_at": built_at,
-        "packer_version": PACKER_VERSION,
-        "content_uri_count": counts,
-        "tool_count": tool_count,
-    }
-
-
-def pack(root: Path, out_dir: Path) -> dict[str, Any]:
-    """Run the full pack. Returns the manifest dict."""
-    uris, errors = _collect_entries(root)
-    if not uris:
-        sys.stderr.write("pack: empty content (zero URIs)\n")
-        for line in errors:
-            sys.stderr.write(f"  - {line}\n")
-        raise SystemExit(2)
-
-    tool_catalog = load_tool_catalog_raw()
-    content_hash, signature = _content_signature(uris, tool_catalog)
-    counts = _count_kinds(uris)
-    built_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-    manifest = _build_manifest(
-        signature=signature,
-        content_hash=content_hash,
-        package_version=_package_version(root),
-        git_sha=_git_sha(root),
-        built_at=built_at,
-        counts=counts,
-        tool_count=len(tool_catalog.get("tools", [])),
-    )
-
-    blob = {
-        "schema_version": SCHEMA_VERSION,
-        "uris": uris,
-        "tool_catalog": tool_catalog,
-        "manifest": manifest,
-    }
-    # Compact JSON for the bundle (saves ~20 KB vs indent=2). The R2
-    # archival copy is gzipped, so legibility there is moot.
-    payload = json.dumps(blob, ensure_ascii=False, sort_keys=True)
-    payload_bytes = payload.encode("utf-8")
-
-    if len(payload_bytes) > MAX_UNCONDENSED_BYTES:
-        sys.stderr.write(
-            f"pack: uncondensed content {len(payload_bytes)} bytes "
-            f"exceeds limit {MAX_UNCONDENSED_BYTES}\n"
-        )
-        raise SystemExit(1)
-
-    out_dir.mkdir(parents=True, exist_ok=True)
-    (out_dir / "content.json").write_bytes(payload_bytes)
-    # mtime=0 keeps the gzip header byte-stable across CI runs so the
-    # R2 archival copy hashes deterministically.
-    with open(out_dir / "content.json.gz", "wb") as raw:
-        with gzip.GzipFile(
-            fileobj=raw, mode="wb", compresslevel=9, mtime=0
-        ) as gz:
-            gz.write(payload_bytes)
-    (out_dir / "manifest.json").write_text(
-        json.dumps(manifest, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
-        encoding="utf-8",
-    )
-
-    if errors:
-        sys.stderr.write("pack: non-fatal frontmatter errors:\n")
-        for line in errors:
-            sys.stderr.write(f"  - {line}\n")
-
-    return manifest
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "--root", type=Path, default=_repo_root(), help="Repository root."
-    )
-    parser.add_argument(
-        "--out",
-        type=Path,
-        default=None,
-        help="Output directory (defaults to <root>/internal/workers/mcp).",
-    )
-    parser.add_argument(
-        "--quiet", action="store_true", help="Suppress success summary."
-    )
-    args = parser.parse_args(argv)
-
-    out_dir = args.out or (args.root / "internal" / "workers" / "mcp")
-    manifest = pack(args.root, out_dir)
-
-    if not args.quiet:
-        c = manifest["content_uri_count"]
-        sys.stderr.write(
-            f"pack: ok signature={manifest['signature']} "
-            f"release={manifest['release_key']} "
-            f"skills={c['skill']} commands={c['command']} "
-            f"rules={c['rule']} guidelines={c['guideline']} "
-            f"contexts={c['context']} tools={manifest['tool_count']}\n"
-        )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())