@event4u/agent-config 1.38.0 → 1.40.0

package/scripts/install

@@ -15,13 +15,30 @@
 #   --source <dir>    Package source directory (default: auto-detect)
 #   --target <dir>    Target project root (default: cwd)
 #   --profile <name>  Cost profile for bridges (minimal|balanced|full)
+#   --tools <list>    Comma-separated tool IDs to install (default: all).
+#                     Valid: claude-code,claude-desktop,cursor,windsurf,
+#                            cline,gemini-cli,copilot,augment,aider,codex,all
+#   --list-tools      Print supported tool IDs with descriptions, then exit
+#   --yes, -y         Non-interactive mode: do not prompt (default for non-TTY)
 #   --force           Overwrite existing bridge files
 #   --dry-run         Show what payload sync would do (does not run bridges)
 #   --verbose         Detailed payload sync output
 #   --quiet           Suppress non-error output
 #   --skip-sync       Skip payload sync (install.sh)
 #   --skip-bridges    Skip bridge files (install.py)
+#   --global          Phase-3: ship kernel rules + curated skills to user-scope
+#                     dirs (~/.claude/, ~/.cursor/, ~/.codeium/windsurf/,
+#                     ~/.config/agent-config/) so the agent has them in every
+#                     project. Pair with --tools to scope surfaces; default = all.
+#   --uninstall       With --global: remove the event4u/ namespace dir from each
+#                     enabled surface (no effect on user-added files).
 #   --help, -h        Show this help
+#
+# Examples:
+#   bash scripts/install                                # everything (default)
+#   bash scripts/install --tools=claude-code,cursor     # only those two
+#   bash scripts/install --tools=cursor --yes           # CI-friendly
+#   bash scripts/install --list-tools                   # show catalog
 
 set -uo pipefail
 
@@ -32,19 +49,67 @@ INSTALL_PY="$SCRIPT_DIR/install.py"
 SOURCE_DIR=""
 TARGET_DIR=""
 PROFILE=""
+TOOLS=""
+TOOLS_EXPLICIT=false
+YES=false
 FORCE=false
 DRY_RUN=false
 VERBOSE=false
 QUIET=false
 SKIP_SYNC=false
 SKIP_BRIDGES=false
+LIST_TOOLS=false
+GLOBAL_INSTALL=false
+UNINSTALL=false
+
+# Single source of truth for valid tool IDs (also referenced by install.sh / install.py).
+VALID_TOOLS="claude-code claude-desktop cursor windsurf cline gemini-cli copilot augment aider codex all"
 
 show_help() {
-    sed -n '3,25p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+    sed -n '3,35p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+}
+
+list_tools() {
+    cat <<'EOF'
+Supported --tools IDs (default: all):
+
+  claude-code      .claude/rules, .claude/skills, .claude/commands, .claude/settings.json
+  claude-desktop   ~/Library/Application Support/Claude/ (global, see Phase 4 docs)
+  cursor           .cursor/rules, .cursor/commands (legacy .cursorrules also written)
+  windsurf         .windsurf/rules, .windsurf/workflows (legacy .windsurfrules also written)
+  cline            .clinerules/ symlinks
+  gemini-cli       GEMINI.md, .gemini/settings.json
+  copilot          .github/copilot-instructions.md, .vscode/settings.json
+  augment          .augment/ payload + settings (substrate — recommended for every install)
+  aider            AGENTS.md (Linux Foundation cross-tool contract; always written)
+  codex            AGENTS.md (same as aider — no extra action)
+  all              every ID above (the default; backward-compatible)
+
+Examples:
+  --tools=claude-code,cursor       project-local install for those two surfaces
+  --tools=all                      equivalent to omitting the flag
+EOF
 }
 
 err() { echo "  ❌  $*" >&2; }
 
+# Validate a comma-separated tool list against $VALID_TOOLS. Empty input is
+# rejected so a stray --tools= does not silently behave like --tools=all.
+validate_tools() {
+    local raw="$1"
+    [[ -z "$raw" ]] && { err "--tools requires a non-empty value (use --list-tools to see options)"; return 1; }
+    local IFS=','
+    local item
+    for item in $raw; do
+        [[ -z "$item" ]] && { err "--tools contains an empty entry"; return 1; }
+        if [[ " $VALID_TOOLS " != *" $item "* ]]; then
+            err "Unknown tool ID: $item (run --list-tools for the catalog)"
+            return 1
+        fi
+    done
+    return 0
+}
+
 while [[ $# -gt 0 ]]; do
     case "$1" in
         --source)        SOURCE_DIR="$2"; shift 2 ;;
@@ -53,17 +118,84 @@ while [[ $# -gt 0 ]]; do
         --target=*)      TARGET_DIR="${1#*=}"; shift ;;
         --profile)       PROFILE="$2"; shift 2 ;;
         --profile=*)     PROFILE="${1#*=}"; shift ;;
+        --tools)         TOOLS="$2"; TOOLS_EXPLICIT=true; shift 2 ;;
+        --tools=*)       TOOLS="${1#*=}"; TOOLS_EXPLICIT=true; shift ;;
+        --list-tools)    LIST_TOOLS=true; shift ;;
+        --yes|-y)        YES=true; shift ;;
         --force)         FORCE=true; shift ;;
         --dry-run)       DRY_RUN=true; shift ;;
         --verbose)       VERBOSE=true; shift ;;
         --quiet)         QUIET=true; shift ;;
         --skip-sync)     SKIP_SYNC=true; shift ;;
         --skip-bridges)  SKIP_BRIDGES=true; shift ;;
+        --global)        GLOBAL_INSTALL=true; shift ;;
+        --uninstall)     UNINSTALL=true; shift ;;
         --help|-h)       show_help; exit 0 ;;
         *)               err "Unknown argument: $1"; show_help >&2; exit 1 ;;
     esac
 done
 
+if $LIST_TOOLS; then
+    list_tools
+    exit 0
+fi
+
+# Interactive --tools picker (S9). Fires only when:
+#   - --tools was not explicitly passed
+#   - --yes / -y was not passed (CI / non-interactive opt-out)
+#   - stdin AND stdout are both TTYs (so we're not in a pipe / curl|bash flow)
+#   - --dry-run, --quiet, --skip-sync, --skip-bridges did not opt out of UX
+# Otherwise we fall through to the backward-compatible "all" default.
+prompt_tools() {
+    local choice picked tool i=0
+    local -a menu=(claude-code claude-desktop cursor windsurf cline gemini-cli copilot augment aider codex)
+    echo ""
+    echo "  📦 Pick the tools to install (comma-separated numbers, blank = all):"
+    for tool in "${menu[@]}"; do
+        i=$((i+1))
+        printf "    %2d) %s\n" "$i" "$tool"
+    done
+    echo "    a)  all (default)"
+    echo ""
+    printf "  Selection: "
+    IFS= read -r choice || choice=""
+    choice="${choice// /}"
+    if [[ -z "$choice" || "$choice" == "a" || "$choice" == "all" ]]; then
+        TOOLS="all"; return
+    fi
+    picked=""
+    local IFS=','
+    for n in $choice; do
+        if ! [[ "$n" =~ ^[0-9]+$ ]] || (( n < 1 || n > ${#menu[@]} )); then
+            err "Invalid selection: $n (expected 1-${#menu[@]} or 'a')"; exit 1
+        fi
+        picked+="${menu[$((n-1))]},"
+    done
+    TOOLS="${picked%,}"
+    echo "  ✅  Selected: $TOOLS"
+}
+
+if ! $TOOLS_EXPLICIT && ! $YES && ! $QUIET && ! $LIST_TOOLS && ! $GLOBAL_INSTALL && [[ -t 0 && -t 1 ]]; then
+    prompt_tools
+    TOOLS_EXPLICIT=true
+fi
+
+if $UNINSTALL && ! $GLOBAL_INSTALL; then
+    err "--uninstall is only valid combined with --global"
+    exit 1
+fi
+
+# Default = "all": backward compatible with pre-Phase-1 invocations. An
+# explicit --tools= (empty value) is rejected by validate_tools — only an
+# absent flag falls through to "all".
+if ! $TOOLS_EXPLICIT && [[ -z "$TOOLS" ]]; then
+    TOOLS="all"
+fi
+
+if ! validate_tools "$TOOLS"; then
+    exit 1
+fi
+
 # Auto-detect source: directory above this script
 if [[ -z "$SOURCE_DIR" ]]; then
     SOURCE_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
@@ -103,6 +235,7 @@ run_sync() {
     $DRY_RUN && args+=(--dry-run)
     $VERBOSE && args+=(--verbose)
     $QUIET   && args+=(--quiet)
+    args+=(--tools="$TOOLS")
     bash "$INSTALL_SH" "${args[@]}"
 }
 
@@ -123,10 +256,32 @@ run_bridges() {
     [[ -n "$PROFILE" ]] && args+=(--profile="$PROFILE")
     $FORCE && args+=(--force)
     $QUIET && args+=(--quiet)
+    args+=(--tools="$TOOLS")
     "$python_bin" "$INSTALL_PY" "${args[@]}"
 }
 
 RC=0
+
+# --global: dedicated user-scope path. Skips the project-bridge sync entirely
+# and forwards to install.py --global (Phase 3 / S13). --uninstall pairs with
+# --global to wipe the event4u/ namespace dir under each surface.
+if $GLOBAL_INSTALL; then
+    if ! python_bin="$(find_python)"; then
+        err "Python 3 not found — required for --global install"
+        exit 1
+    fi
+    if [[ ! -f "$INSTALL_PY" ]]; then
+        err "Missing $INSTALL_PY"
+        exit 1
+    fi
+    args=(--package "$SOURCE_DIR" --global --tools="$TOOLS")
+    $FORCE     && args+=(--force)
+    $QUIET     && args+=(--quiet)
+    $UNINSTALL && args+=(--uninstall)
+    "$python_bin" "$INSTALL_PY" "${args[@]}"
+    exit $?
+fi
+
 if ! $SKIP_SYNC; then
     if [[ ! -f "$INSTALL_SH" ]]; then
         err "Missing $INSTALL_SH"

package/scripts/install.py

@@ -1217,6 +1217,189 @@ def _smoke_test_hooks(project_root: Path, package_root: Path) -> int:
     return 1 if failed else 0
 
 
+# --- Global user-level install (Phase 3 — road-to-simplicity-and-everywhere) ---
+#
+# `scripts/install --global` ships kernel rules + a curated top-N of skills
+# into per-tool user-scope directories so the agent has them in every
+# project on the machine. Curation lives in templates/global-install-manifest.yml.
+#
+# Files are written under an `event4u/` namespace so `--global --uninstall`
+# can wipe the namespace dir without touching user-added files.
+
+GLOBAL_NAMESPACE = "event4u"
+GLOBAL_MANIFEST_REL = Path("templates") / "global-install-manifest.yml"
+
+# Per-tool global directories. Each surface gets a `rules/` and `skills/`
+# bucket under the event4u/ namespace. claude-desktop reuses claude-code's
+# ~/.claude/ (the two surfaces share the dir per Anthropic's docs).
+GLOBAL_TOOL_DIRS: dict[str, dict[str, Path]] = {
+    "claude-code": {
+        "rules":  Path.home() / ".claude" / "rules"  / GLOBAL_NAMESPACE,
+        "skills": Path.home() / ".claude" / "skills" / GLOBAL_NAMESPACE,
+    },
+    "cursor": {
+        "rules":  Path.home() / ".cursor" / "rules"  / "imported" / GLOBAL_NAMESPACE / "rules",
+        "skills": Path.home() / ".cursor" / "rules"  / "imported" / GLOBAL_NAMESPACE / "skills",
+    },
+    "windsurf": {
+        "rules":  Path.home() / ".codeium" / "windsurf" / "global_workflows" / GLOBAL_NAMESPACE / "rules",
+        "skills": Path.home() / ".codeium" / "windsurf" / "global_workflows" / GLOBAL_NAMESPACE / "skills",
+    },
+    "fallback": {
+        "rules":  Path.home() / ".config" / "agent-config" / "rules"  / GLOBAL_NAMESPACE,
+        "skills": Path.home() / ".config" / "agent-config" / "skills" / GLOBAL_NAMESPACE,
+    },
+}
+
+
+def _load_global_manifest(package_root: Path) -> dict:
+    """Parse templates/global-install-manifest.yml without a YAML dep.
+
+    Tiny hand-rolled parser — only handles the manifest's flat shape:
+    `key: value`, `- item`, and `- key: value` indented under a parent
+    list. We avoid pulling in PyYAML so install.py stays zero-dep.
+    """
+    path = package_root / GLOBAL_MANIFEST_REL
+    if not path.is_file():
+        fail(f"global manifest missing: {path}")
+    out: dict = {"kernel_rules": [], "top_skills": []}
+    section: str | None = None
+    pending: dict | None = None
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.split("#", 1)[0].rstrip()
+        if not line.strip():
+            continue
+        if line.startswith("kernel_rules:"):
+            section = "kernel_rules"; pending = None; continue
+        if line.startswith("top_skills:"):
+            section = "top_skills"; pending = None; continue
+        stripped = line.lstrip()
+        indent = len(line) - len(stripped)
+        if section == "kernel_rules" and stripped.startswith("- "):
+            out["kernel_rules"].append(stripped[2:].strip())
+        elif section == "top_skills":
+            if stripped.startswith("- id:"):
+                if pending is not None:
+                    out["top_skills"].append(pending)
+                pending = {"id": stripped.split(":", 1)[1].strip(), "surfaces": []}
+            elif pending is not None and stripped.startswith("surfaces:"):
+                raw_list = stripped.split(":", 1)[1].strip()
+                if raw_list.startswith("[") and raw_list.endswith("]"):
+                    pending["surfaces"] = [s.strip() for s in raw_list[1:-1].split(",") if s.strip()]
+            elif indent == 0 and not stripped.startswith("-"):
+                section = None
+    if pending is not None:
+        out["top_skills"].append(pending)
+    return out
+
+
+def _resolve_skill_source(package_root: Path, skill_id: str) -> Path | None:
+    """Locate a skill's SKILL.md in the package. Prefers .claude/skills/."""
+    for base in (package_root / ".claude" / "skills",
+                 package_root / ".agent-src" / "skills"):
+        candidate = base / skill_id / "SKILL.md"
+        if candidate.is_file():
+            return candidate.parent
+    return None
+
+
+def _resolve_rule_source(package_root: Path, rule_id: str) -> Path | None:
+    """Locate a rule's .md in the package. Prefers .agent-src/rules/."""
+    for base in (package_root / ".agent-src" / "rules",
+                 package_root / ".augment" / "rules"):
+        candidate = base / f"{rule_id}.md"
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _global_targets(tools: set[str]) -> dict[str, dict[str, Path]]:
+    """Return the subset of GLOBAL_TOOL_DIRS to write to. Fallback always on."""
+    targets: dict[str, dict[str, Path]] = {"fallback": GLOBAL_TOOL_DIRS["fallback"]}
+    for tool_id, dirs in GLOBAL_TOOL_DIRS.items():
+        if tool_id == "fallback":
+            continue
+        # claude-desktop shares claude-code's dir — both flip the same target.
+        if tool_id == "claude-code" and ("claude-code" in tools or "claude-desktop" in tools):
+            targets[tool_id] = dirs
+        elif tool_id in tools:
+            targets[tool_id] = dirs
+    return targets
+
+
+def install_global(package_root: Path, tools: set[str], force: bool) -> int:
+    """S13/S14: ship kernel rules + curated skills to user-scope dirs."""
+    import shutil
+    manifest = _load_global_manifest(package_root)
+    targets = _global_targets(tools)
+
+    if not QUIET:
+        info(f"Global install — surfaces: {', '.join(sorted(targets))}")
+        info(f"  rules:  {len(manifest['kernel_rules'])}")
+        info(f"  skills: {len(manifest['top_skills'])}")
+
+    for surface, dirs in targets.items():
+        for kind in ("rules", "skills"):
+            dirs[kind].mkdir(parents=True, exist_ok=True)
+        # Rules: copy each kernel rule (file).
+        for rule_id in manifest["kernel_rules"]:
+            src = _resolve_rule_source(package_root, rule_id)
+            if src is None:
+                warn(f"global: rule '{rule_id}' missing in package — skipped")
+                continue
+            dst = dirs["rules"] / f"{rule_id}.md"
+            if dst.exists() and not force and dst.read_bytes() == src.read_bytes():
+                continue
+            dst.write_bytes(src.read_bytes())
+        # Skills: copy each curated skill (directory).
+        for entry in manifest["top_skills"]:
+            if surface != "fallback" and surface not in entry.get("surfaces", []):
+                continue
+            src_dir = _resolve_skill_source(package_root, entry["id"])
+            if src_dir is None:
+                warn(f"global: skill '{entry['id']}' missing in package — skipped")
+                continue
+            dst_dir = dirs["skills"] / entry["id"]
+            if dst_dir.exists() and not force:
+                shutil.rmtree(dst_dir)
+            shutil.copytree(src_dir, dst_dir)
+        if not QUIET:
+            success(f"  {surface}: {dirs['rules']}, {dirs['skills']}")
+    return 0
+
+
+def uninstall_global(tools: set[str]) -> int:
+    """S15: remove the event4u/ namespace dir from each enabled surface."""
+    import shutil
+    targets = _global_targets(tools)
+    removed: list[str] = []
+    # Collect ancestor dirs named GLOBAL_NAMESPACE so we can drop the
+    # shared parent (e.g. cursor/windsurf put rules + skills as siblings
+    # under one event4u/ dir; removing both leaves a stranded namespace
+    # dir). We never delete anything not literally named event4u/.
+    namespace_parents: set[Path] = set()
+    for surface, dirs in targets.items():
+        for kind in ("rules", "skills"):
+            d = dirs[kind]
+            if d.exists():
+                shutil.rmtree(d)
+                removed.append(str(d))
+            for ancestor in d.parents:
+                if ancestor.name == GLOBAL_NAMESPACE:
+                    namespace_parents.add(ancestor)
+    for parent in namespace_parents:
+        if parent.is_dir() and not any(parent.iterdir()):
+            parent.rmdir()
+            removed.append(str(parent))
+    if not QUIET:
+        if removed:
+            for r in removed:
+                success(f"removed {r}")
+        else:
+            skip("global uninstall: nothing to remove")
+    return 0
+
+
 # --- Argument parsing ---
 
 def parse_options(argv: list[str]) -> argparse.Namespace:
@@ -1260,14 +1443,70 @@ def parse_options(argv: list[str]) -> argparse.Namespace:
     parser.add_argument("--project", default=None, help="project root (default: cwd or PROJECT_ROOT env)")
     parser.add_argument("--package", default=None, help="package root (default: auto-detect under project)")
     parser.add_argument("--quiet", action="store_true", help="suppress info/success output (warnings/errors still shown)")
+    parser.add_argument(
+        "--tools",
+        default="all",
+        help=(
+            "comma-separated tool IDs to install bridges for "
+            "(claude-code,cursor,windsurf,cline,gemini-cli,copilot,augment,aider,codex,all). "
+            "Default: all (backward-compatible)."
+        ),
+    )
     parser.add_argument(
         "--no-smoke",
         action="store_true",
         help="skip the post-install hook smoke test (default: dry-fire dispatch:hook against every installed bridge)",
     )
+    parser.add_argument(
+        "--global",
+        dest="global_install",
+        action="store_true",
+        help=(
+            "Phase-3 mode: ship kernel rules + curated top-N skills to user-scope "
+            "dirs (~/.claude/, ~/.cursor/, ~/.codeium/windsurf/, ~/.config/agent-config/) "
+            "so the agent has them in every project. Curation: templates/global-install-manifest.yml."
+        ),
+    )
+    parser.add_argument(
+        "--uninstall",
+        action="store_true",
+        help="With --global: remove the event4u/ namespace dir from each enabled surface.",
+    )
     return parser.parse_args(argv)
 
 
+# Mapping of --tools IDs accepted by install.py. Mirrors VALID_TOOLS in
+# scripts/install. Bridges keyed off these IDs are gated; substrate
+# bridges (vscode, augment) always run.
+_VALID_TOOLS = {
+    "claude-code", "claude-desktop", "cursor", "windsurf", "cline",
+    "gemini-cli", "copilot", "augment", "aider", "codex", "all",
+}
+
+
+def _parse_tools(raw: str) -> set[str]:
+    """Parse and validate --tools value. Returns set of normalized IDs.
+
+    "all" expands to every concrete ID. Empty input is rejected.
+    Unknown IDs raise SystemExit so the caller's message reaches stderr.
+    """
+    if not raw or not raw.strip():
+        fail("--tools requires a non-empty value")
+    items = [s.strip() for s in raw.split(",") if s.strip()]
+    if not items:
+        fail("--tools requires at least one ID")
+    unknown = [s for s in items if s not in _VALID_TOOLS]
+    if unknown:
+        fail(f"--tools: unknown ID(s): {', '.join(unknown)} (valid: {', '.join(sorted(_VALID_TOOLS))})")
+    if "all" in items:
+        return {t for t in _VALID_TOOLS if t != "all"}
+    return set(items)
+
+
+def _is_tool_enabled(tools: set[str], tool_id: str) -> bool:
+    return tool_id in tools
+
+
 # --- Main ---
 
 def main(argv: list[str]) -> int:
@@ -1300,31 +1539,52 @@ def main(argv: list[str]) -> int:
         info(f"Profile:  {opts.profile}")
         print()
 
+    # --global: short-circuits the project-bridge path. Ships kernel rules
+    # + curated skills to user-scope dirs and exits. --uninstall pairs
+    # with --global to remove the namespace dir.
+    if opts.global_install:
+        tools = _parse_tools(opts.tools)
+        if opts.uninstall:
+            return uninstall_global(tools)
+        return install_global(package_root, tools, opts.force)
+    if opts.uninstall:
+        fail("--uninstall is only valid combined with --global")
+
     ensure_agent_settings(project_root, package_root, opts.profile, opts.force)
 
+    tools = _parse_tools(opts.tools)
+
     if not opts.skip_bridges:
+        # Substrate bridges (always written; other tools symlink/depend on them).
         ensure_vscode_bridge(project_root, package_type, opts.force)
         ensure_augment_bridge(project_root, opts.force)
-        ensure_claude_bridge(project_root, opts.force)
-        ensure_cursor_bridge(project_root, opts.force)
-        ensure_cline_bridge(project_root, opts.force)
-        ensure_windsurf_bridge(project_root, opts.force)
-        ensure_gemini_bridge(project_root, opts.force)
-        ensure_copilot_bridge(project_root, opts.force)
+        # Tool-specific bridges (gated by --tools selection).
+        if _is_tool_enabled(tools, "claude-code"):
+            ensure_claude_bridge(project_root, opts.force)
+        if _is_tool_enabled(tools, "cursor"):
+            ensure_cursor_bridge(project_root, opts.force)
+        if _is_tool_enabled(tools, "cline"):
+            ensure_cline_bridge(project_root, opts.force)
+        if _is_tool_enabled(tools, "windsurf"):
+            ensure_windsurf_bridge(project_root, opts.force)
+        if _is_tool_enabled(tools, "gemini-cli"):
+            ensure_gemini_bridge(project_root, opts.force)
+        if _is_tool_enabled(tools, "copilot"):
+            ensure_copilot_bridge(project_root, opts.force)
 
     if opts.augment_user_hooks:
         ensure_augment_user_hooks(package_root, opts.force)
 
-    if opts.cursor_user_hooks:
+    if opts.cursor_user_hooks and _is_tool_enabled(tools, "cursor"):
         ensure_cursor_user_hooks(package_root, opts.force)
 
-    if opts.cline_user_hooks:
+    if opts.cline_user_hooks and _is_tool_enabled(tools, "cline"):
         ensure_cline_user_hooks(package_root, opts.force)
 
-    if opts.windsurf_user_hooks:
+    if opts.windsurf_user_hooks and _is_tool_enabled(tools, "windsurf"):
         ensure_windsurf_user_hooks(package_root, opts.force)
 
-    if opts.gemini_user_hooks:
+    if opts.gemini_user_hooks and _is_tool_enabled(tools, "gemini-cli"):
         ensure_gemini_user_hooks(package_root, opts.force)
 
     if not opts.skip_bridges and not opts.no_smoke: