@ainova-systems/intelligence 0.11.0-rc.1

package/engine/scripts/adapters/copilot.sh

@@ -0,0 +1,193 @@
+#!/bin/bash
+# intelligence-sync: GitHub Copilot adapter
+# Transforms source prompts to .github/ format
+#
+# Rules:
+#   - Path-scoped (with `paths:`) -> .github/instructions/{name}.instructions.md (applyTo:)
+#   - Always-on (no `paths:`)     -> SKIPPED here. Copilot reads AGENTS.md
+#     natively, and the `agents` adapter inlines always-on rule content
+#     into AGENTS.md. We also do not generate .github/copilot-instructions.md
+#     because Copilot bug copilot-cli#489 makes AGENTS.md ignored when
+#     copilot-instructions.md is present.
+# Skills: copy skill directories in full to .github/skills/{name}/
+# Agents: -> .github/agents/{name}.agent.md (description, tools, model)
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Sync rules to Copilot format. Only path-scoped rules are emitted —
+# always-on rules live in AGENTS.md (read by Copilot natively).
+sync_copilot_rules() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    local instructions_dir="$output_dir/instructions"
+    mkdir -p "$instructions_dir"
+
+    local scoped_count=0
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for f in "$dir"/*.md; do
+            [ -f "$f" ] || continue
+            local hp
+            hp=$(has_paths "$f")
+
+            # Skip always-on rules: AGENTS.md carries them.
+            [ "$hp" -eq 0 ] && continue
+
+            local base
+            base="$(basename "$f" .md)"
+
+            local paths_line
+            paths_line=$(awk '
+                { sub(/\r$/, "") }
+                /^paths:/ { in_paths=1; next }
+                in_paths && /^  - / {
+                    val = $0
+                    sub(/^  - /, "", val)
+                    gsub(/["\047]/, "", val)
+                    printf "%s%s", sep, val
+                    sep = ","
+                }
+                in_paths && !/^  - / && !/^$/ { exit }
+                END { print "" }
+            ' "$f")
+
+            {
+                echo "---"
+                echo "applyTo: \"$paths_line\""
+                echo "---"
+                echo ""
+                awk '
+                    BEGIN { in_fm=0; past_fm=0 }
+                    { sub(/\r$/, "") }
+                    /^---$/ {
+                        if (!past_fm) { in_fm = !in_fm; if (!in_fm) { past_fm=1 }; next }
+                    }
+                    past_fm || !in_fm { print }
+                ' "$f"
+            } > "$instructions_dir/$base.instructions.md"
+            finalize_output_file "$instructions_dir/$base.instructions.md"
+            scoped_count=$((scoped_count + 1))
+            echo "  rule: $base.instructions.md (scoped)"
+        done
+    done < <(read_yaml_list "$config_file" "rules")
+
+    echo "  rules: $scoped_count scoped"
+}
+
+# Sync skills to Copilot format (SKILL.md in .github/skills/)
+sync_copilot_skills() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    local count=0
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for d in "$dir"/*/; do
+            [ -d "$d" ] || continue
+            local skill_name
+            skill_name="$(basename "$d")"
+            [ -f "$d/SKILL.md" ] || continue
+            copy_skill_bundle "$d" "$output_dir/skills/$skill_name"
+            count=$((count + 1))
+            echo "  skill: $skill_name"
+        done
+    done < <(read_yaml_list "$config_file" "skills")
+
+    echo "  -> Skills: $count"
+}
+
+# Sync agents to Copilot format (.github/agents/{name}.agent.md)
+sync_copilot_agents() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    local count=0
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for f in "$dir"/*.md; do
+            [ -f "$f" ] || continue
+            local name
+            name="$(basename "$f" .md)"
+
+            local tier access description
+            tier=$(get_frontmatter_value "tier" "$f")
+            access=$(get_frontmatter_value "access" "$f")
+            description=$(get_frontmatter_value "description" "$f")
+
+            local model
+            model=$(get_model "$config_file" "copilot" "$tier")
+
+            # Build tools list based on access. Tool aliases per Copilot custom-agent
+            # spec: `read`, `search`, `edit`, `execute`, `agent`, `web`, `todo`, `*`.
+            # Omitting `tools:` grants all; restrict to read/search for readonly access.
+            local tools_line=""
+            if [ "$access" = "readonly" ]; then
+                tools_line="tools: [\"read\", \"search\"]"
+            fi
+
+            local description_escaped
+            description_escaped=$(yaml_dq_escape "$description")
+
+            # Generate .agent.md: replace tier/access with description/model/tools
+            {
+                echo "---"
+                echo "description: \"$description_escaped\""
+                echo "model: $model"
+                [ -n "$tools_line" ] && echo "$tools_line"
+                echo "---"
+                echo ""
+                # Strip original frontmatter, keep body
+                awk '
+                    BEGIN { in_fm=0; past_fm=0 }
+                    { sub(/\r$/, "") }
+                    /^---$/ {
+                        if (!past_fm) { in_fm = !in_fm; if (!in_fm) { past_fm=1 }; next }
+                    }
+                    past_fm { print }
+                ' "$f"
+            } > "$output_dir/agents/$name.agent.md"
+            finalize_output_file "$output_dir/agents/$name.agent.md"
+            count=$((count + 1))
+            echo "  agent: $name.agent.md (tier=$tier -> model=$model)"
+        done
+    done < <(read_yaml_list "$config_file" "agents")
+
+    echo "  -> Agents: $count"
+}
+
+# Main entry point for Copilot adapter
+sync_to_copilot() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== GitHub Copilot ==="
+
+    # Clean generated content (preserve workflows, etc.)
+    rm -rf "$output_dir/instructions" "$output_dir/prompts"
+    if [ -d "$output_dir/skills" ]; then
+        find "$output_dir/skills" -mindepth 1 -maxdepth 1 -type d | while read -r d; do
+            rm -rf "$d"
+        done
+    fi
+    rm -rf "$output_dir/agents"
+    mkdir -p "$output_dir" "$output_dir/skills" "$output_dir/agents"
+
+    sync_copilot_rules "$repo_root" "$config_file" "$output_dir"
+    sync_copilot_skills "$repo_root" "$config_file" "$output_dir"
+    sync_copilot_agents "$repo_root" "$config_file" "$output_dir"
+}

package/engine/scripts/adapters/cursor.sh

@@ -0,0 +1,146 @@
+#!/bin/bash
+# intelligence-sync: Cursor adapter
+# Transforms source prompts to .cursor/ format
+#
+# Rules:
+#   - Path-scoped (with `paths:`)  -> .cursor/rules/<name>.mdc with `globs:`
+#   - Always-on (no `paths:`)      -> SKIPPED here. Cursor reads AGENTS.md
+#     natively for project-level context, and the `agents` adapter inlines
+#     always-on rule content into AGENTS.md. Generating .mdc copies of the
+#     same rules would cause double-loading and burn the context window.
+# Skills: copy skill directories in full (SKILL.md + bundled resources)
+# Agents: strip tier/access/tools/disallowedTools, add model + readonly:true
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Sync rules to Cursor format (.md -> .mdc, paths -> globs)
+sync_cursor_rules() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for f in "$dir"/*.md; do
+            [ -f "$f" ] || continue
+            local hp
+            hp=$(has_paths "$f")
+
+            # Skip always-on rules: AGENTS.md (canonical) carries them.
+            if [ "$hp" -eq 0 ]; then
+                continue
+            fi
+
+            local base
+            base="$(basename "$f" .md)"
+
+            # Path-scoped rule -> Auto Attached (paths -> globs)
+            awk '
+                {
+                    sub(/\r$/, "")
+                    sub(/^paths:/, "globs:")
+                }
+                NR==1 { print; print "alwaysApply: false"; next }
+                { print }
+            ' "$f" > "$output_dir/rules/$base.mdc"
+            finalize_output_file "$output_dir/rules/$base.mdc"
+            echo "  rule: $base.mdc (scoped)"
+        done
+    done < <(read_yaml_list "$config_file" "rules")
+}
+
+# Sync skills to Cursor format (copy as-is)
+sync_cursor_skills() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for d in "$dir"/*/; do
+            [ -d "$d" ] || continue
+            local skill_name
+            skill_name="$(basename "$d")"
+            [ -f "$d/SKILL.md" ] || continue
+            copy_skill_bundle "$d" "$output_dir/skills/$skill_name"
+            echo "  skill: $skill_name"
+        done
+    done < <(read_yaml_list "$config_file" "skills")
+}
+
+# Sync agents to Cursor format
+sync_cursor_agents() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for f in "$dir"/*.md; do
+            [ -f "$f" ] || continue
+            local name
+            name="$(basename "$f")"
+
+            local tier access
+            tier=$(get_frontmatter_value "tier" "$f")
+            access=$(get_frontmatter_value "access" "$f")
+
+            local cursor_model cursor_readonly
+            cursor_model=$(get_model "$config_file" "cursor" "$tier")
+            cursor_readonly=""
+            [ "$access" = "readonly" ] && cursor_readonly="readonly: true"
+
+            # Always emit model: line (even when value matches Cursor's default)
+            # so config is explicit and grep-able.
+            awk -v cm="$cursor_model" -v cr="$cursor_readonly" '
+                BEGIN { count=0 }
+                /^tier:/  { next }
+                /^access:/ { next }
+                /^tools:/ { next }
+                /^disallowedTools:/ { next }
+                {
+                    sub(/\r$/, "")
+                }
+                /^---$/ { count++ }
+                count==2 && /^---$/ {
+                    print "model: " cm
+                    if (cr != "") print cr
+                }
+                { print }
+            ' "$f" > "$output_dir/agents/$name"
+            finalize_output_file "$output_dir/agents/$name"
+            echo "  agent: $name (tier=$tier -> cursor)"
+        done
+    done < <(read_yaml_list "$config_file" "agents")
+}
+
+# Main entry point for Cursor adapter
+sync_to_cursor() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== Cursor ==="
+
+    rm -rf "$output_dir/rules" "$output_dir/agents" "$output_dir/skills"
+    mkdir -p "$output_dir/rules" "$output_dir/skills" "$output_dir/agents"
+
+    sync_cursor_rules "$repo_root" "$config_file" "$output_dir"
+    sync_cursor_skills "$repo_root" "$config_file" "$output_dir"
+    sync_cursor_agents "$repo_root" "$config_file" "$output_dir"
+
+    local rules_count skills_count agents_count
+    rules_count=$(find "$output_dir/rules" -name "*.mdc" 2>/dev/null | wc -l)
+    skills_count=$(find "$output_dir/skills" -name "SKILL.md" 2>/dev/null | wc -l)
+    agents_count=$(find "$output_dir/agents" -name "*.md" 2>/dev/null | wc -l)
+    echo "  -> Rules: $rules_count (.mdc), Skills: $skills_count, Agents: $agents_count"
+}

package/engine/scripts/adapters/opencode.sh

@@ -0,0 +1,200 @@
+#!/bin/bash
+# intelligence-sync: opencode adapter
+# Transforms source prompts to opencode's native resource model.
+#
+# Rules:
+#   - Always-on (no `paths:`) -> SKIPPED here. opencode reads AGENTS.md
+#     natively as its primary "Rules" surface (see opencode.ai/docs/rules).
+#   - Path-scoped (with `paths:`) -> SKIPPED. opencode has no first-class
+#     scoped-rule mechanism; users who want scoped rules can opt in via
+#     `instructions:` globs in opencode.json. We do not synthesize that.
+# Skills:
+#   - Copied to .agents/skills/ (Agent Skills open standard; opencode
+#     discovers `.agents/skills/<name>/SKILL.md` natively).
+# Commands:
+#   - For every synced skill, emit `.opencode/commands/<name>.md` so users can
+#     invoke the skill as `/<name> [args]` directly from the slash menu —
+#     replicating the Claude Code UX where every skill is also a slash
+#     command. The command body delegates to the `skill` tool and forwards
+#     `$ARGUMENTS` so any flags from the skill's `argument-hint` reach the
+#     skill script unchanged. Cleanup is marker-based: only files containing
+#     the generation marker are removed, so user-managed commands survive.
+# Agents:
+#   - Converted to .opencode/agents/<name>.md markdown agents
+#     (mode: subagent) with frontmatter description/model/permission. The
+#     body is the source agent's prompt, used directly as the system prompt.
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Strip frontmatter, return body only.
+# Direct call to the shared `strip_frontmatter` helper in lib/common.sh —
+# duplicating the awk block here would violate the "all parsing in common.sh"
+# convention (see CLAUDE.md / docs/CONVENTIONS.md).
+
+sync_opencode_skills() {
+    local repo_root="$1"
+    local config_file="$2"
+    local _output_dir="$3"
+
+    # Skills -> .agents/skills/ (open standard; opencode reads it natively).
+    # `sync_open_skill_dirs` owns clean + populate of this shared dir.
+    local skills_dir="$repo_root/.agents/skills"
+    sync_open_skill_dirs "$repo_root" "$config_file" "$skills_dir"
+}
+
+# Marker line embedded in every generated command file. Cleanup grep's for
+# this exact string before deleting, so any user-authored command without it
+# survives a sync.
+OPENCODE_GEN_MARKER="<!-- Generated by intelligence-sync. Do not edit manually. -->"
+
+# Generate one slash command per synced skill.
+# For each `<src>/<skill>/SKILL.md`, write `.opencode/commands/<skill>.md`
+# with `description:` copied from the skill's `description` (YAML-escaped) and a body that tells the
+# current agent to load the skill via the `skill` tool and pass `$ARGUMENTS`.
+# Files marked with $OPENCODE_GEN_MARKER are removed before regeneration; any
+# user-managed command without the marker is preserved. A user file that
+# shares a name with a skill is overwritten by design — that 1:1 name
+# binding is the whole point of the wrap.
+sync_opencode_commands() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    local commands_dir="$output_dir/commands"
+    mkdir -p "$commands_dir"
+
+    # Marker-based cleanup: leave user-authored commands alone.
+    local f
+    if [ -d "$commands_dir" ]; then
+        for f in "$commands_dir"/*.md; do
+            [ -f "$f" ] || continue
+            if grep -qF "$OPENCODE_GEN_MARKER" "$f" 2>/dev/null; then
+                rm -f "$f"
+            fi
+        done
+    fi
+
+    local count=0
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for d in "$dir"/*/; do
+            [ -d "$d" ] || continue
+            local skill_name
+            skill_name="$(basename "$d")"
+            local skill_md="$d/SKILL.md"
+            [ -f "$skill_md" ] || continue
+
+            local description argument_hint
+            description="$(get_frontmatter_value "description" "$skill_md")"
+            argument_hint="$(get_frontmatter_value "argument-hint" "$skill_md")"
+
+            local out_file="$commands_dir/$skill_name.md"
+            {
+                echo "---"
+                echo "description: \"$(yaml_dq_escape "$description")\""
+                echo "---"
+                echo ""
+                echo "$OPENCODE_GEN_MARKER"
+                echo ""
+                echo "Load and execute the \`$skill_name\` skill via the \`skill\` tool, then run it."
+                echo ""
+                if [ -n "$argument_hint" ]; then
+                    echo "Pass these arguments to the skill: \$ARGUMENTS"
+                    echo ""
+                    echo "Argument hint from the source skill: \`$argument_hint\`"
+                else
+                    echo "Forward any provided arguments to the skill: \$ARGUMENTS"
+                fi
+            } > "$out_file"
+            finalize_output_file "$out_file"
+            count=$((count + 1))
+            echo "  command: /$skill_name"
+        done
+    done < <(read_yaml_list "$config_file" "skills")
+
+    echo "  -> Commands: $count"
+}
+
+sync_opencode_agents() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    local agents_dir="$output_dir/agents"
+    mkdir -p "$agents_dir"
+
+    local count=0
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        for f in "$dir"/*.md; do
+            [ -f "$f" ] || continue
+
+            local name tier access description body
+            name="$(basename "$f" .md)"
+            tier="$(get_frontmatter_value "tier" "$f")"
+            access="$(get_frontmatter_value "access" "$f")"
+            description="$(get_frontmatter_value "description" "$f")"
+            body="$(strip_frontmatter "$f")"
+
+            local model edit_perm bash_perm
+            model="$(get_model "$config_file" "opencode" "$tier")"
+
+            # Map source `access:` to opencode permission keys.
+            # `edit` gates write/edit/apply_patch; `bash` gates shell.
+            case "$access" in
+                readonly) edit_perm="deny";  bash_perm="deny"  ;;
+                *)        edit_perm="allow"; bash_perm="allow" ;;
+            esac
+
+            local out_file="$agents_dir/$name.md"
+            {
+                echo "---"
+                echo "description: \"$(yaml_dq_escape "$description")\""
+                echo "mode: subagent"
+                if [ -n "$model" ]; then
+                    echo "model: \"$(yaml_dq_escape "$model")\""
+                fi
+                echo "permission:"
+                echo "  edit: $edit_perm"
+                echo "  bash: $bash_perm"
+                echo "---"
+                echo ""
+                echo "<!-- Generated by intelligence-sync. Do not edit manually. -->"
+                echo ""
+                printf '%s\n' "$body"
+            } > "$out_file"
+            finalize_output_file "$out_file"
+            count=$((count + 1))
+            echo "  agent: $name.md"
+        done
+    done < <(read_yaml_list "$config_file" "agents")
+
+    echo "  -> Agents: $count"
+}
+
+sync_to_opencode() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== opencode ==="
+
+    # Adapter owns .opencode/agents/ entirely (so removed/renamed source
+    # agents don't linger). Other .opencode/* files (e.g. user-managed
+    # opencode.json) are left untouched. .opencode/commands/ is owned
+    # marker-by-marker — see sync_opencode_commands.
+    rm -rf "$output_dir/agents"
+    mkdir -p "$output_dir/agents"
+
+    sync_opencode_skills "$repo_root" "$config_file" "$output_dir"
+    sync_opencode_commands "$repo_root" "$config_file" "$output_dir"
+    sync_opencode_agents "$repo_root" "$config_file" "$output_dir"
+
+    echo "  -> Rules: skipped (AGENTS.md carries always-on; opencode has no native path-scoped rules)"
+}