@ainova-systems/intelligence 0.11.0-rc.1

package/engine/scripts/adapters/_template.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# intelligence-sync: Adapter template
+# Copy this file to create a new IDE adapter.
+#
+# This file is NOT executable as-is — `<name>` placeholders below would be
+# parsed by bash as input redirection (`<` operator). Replace every
+# occurrence with your adapter name before sourcing.
+#
+# Required:
+#   1. Name the file: <ide-name>.sh (e.g., myide.sh)
+#   2. Replace every `<name>` placeholder with your adapter name
+#   3. Implement sync_to_<name>() function
+#   4. Add target to config.yaml:
+#      targets:
+#        <name>: { enabled: true, output: ".<name>" }
+#
+# The sync_to_<name>() function receives:
+#   $1 = repo_root     — absolute path to the project root
+#   $2 = config_file   — absolute path to config.yaml
+#   $3 = output_dir    — absolute path to the output directory (e.g., .myide/)
+#
+# Available library functions (from lib/common.sh):
+#   normalize_file_to_lf(file)          — fix CRLF line endings
+#   lint_frontmatter(file)              — warn about unquoted colons / leading tabs
+#   get_frontmatter_value(key, file)    — extract YAML frontmatter value
+#   has_frontmatter(file)               — check if file has --- header
+#   has_paths(file)                     — check if file has paths: field
+#   get_model(config, ide, tier)        — resolve model from config or default
+#   get_model_default(ide, tier)        — hardcoded default for ide:tier
+#   map_access_to_claude_tools(access)  — full->"" (no tools list; inherits all), readonly->restricted
+#   map_access_to_claude_disallowed(access) — readonly->"Write, Edit", full->""
+#   read_yaml_list(config, section)     — read list from config.yaml
+#   get_target_field(config, target, field) — read a target's config field
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Sync rules for <agent-name>
+# Typical transformations:
+#   - Copy as-is (like Claude)
+#   - Convert paths: to globs: (like Cursor)
+#   - Merge into single file (like Copilot)
+sync_<name>_rules() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    # TODO: Implement rule sync logic
+    echo "  rules: not implemented"
+}
+
+# Sync skills for <agent-name>
+sync_<name>_skills() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    # TODO: Implement skill sync logic
+    echo "  skills: not implemented"
+}
+
+# Sync agents for <agent-name>
+sync_<name>_agents() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    # TODO: Implement agent sync logic
+    echo "  agents: not implemented"
+}
+
+# Main entry point
+sync_to_<name>() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== <Agent Name> ==="
+
+    # Clean and create output directories
+    rm -rf "$output_dir/rules" "$output_dir/agents" "$output_dir/skills"
+    mkdir -p "$output_dir/rules" "$output_dir/skills" "$output_dir/agents"
+
+    sync_<name>_rules "$repo_root" "$config_file" "$output_dir"
+    sync_<name>_skills "$repo_root" "$config_file" "$output_dir"
+    sync_<name>_agents "$repo_root" "$config_file" "$output_dir"
+}

package/engine/scripts/adapters/agents.sh

@@ -0,0 +1,299 @@
+#!/bin/bash
+# intelligence-sync: AGENTS.md adapter
+# Generates a committed project-index document that lists all agents, skills,
+# and rules discovered from intelligence/ sources.
+#
+# Output: AGENTS.md at repo root (or wherever targets.agents.output points)
+# Header: static text from config.yaml targets.agents.header (block scalar)
+# Body:   auto-built tables/lists from frontmatter of rules/agents/skills
+#
+# Unlike other adapters, the output is a single committed markdown file
+# meant to be read by both humans and LLMs. It must never be hand-edited —
+# every sync regenerates it from scratch.
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Repo-relative paths to the umbrella folder and the engine module, DERIVED —
+# never hardcoded. The umbrella is named by the project (`intelligence/`,
+# `Intelligence/`, a codename) and the engine lives in a module inside it;
+# detect_layout resolved both before any adapter ran. A literal path here would
+# print a sync command that does not exist, and would be wrong outright on a
+# case-sensitive filesystem — in the one document Cursor, Copilot and Codex all
+# read as canonical.
+# sync.sh exports both as layout tokens; recompute only when an adapter is
+# driven directly (tests), never assume a folder name.
+agents_md_umbrella_rel() {
+    local repo_root="$1" rel="${IS_UMBRELLA_REL:-}"
+    [ -n "$rel" ] || rel="$(repo_rel_dir "$repo_root" "${LS_UMBRELLA_DIR:-$repo_root/intelligence}")"
+    printf '%s' "${rel:-intelligence}"
+}
+
+agents_md_module_rel() {
+    local repo_root="$1" rel="${IS_MODULE_REL:-}"
+    [ -n "$rel" ] || rel="$(repo_rel_dir "$repo_root" "${LS_MODULE_DIR:-$repo_root/intelligence/sync}")"
+    printf '%s' "${rel:-intelligence/sync}"
+}
+
+# Append the static header block from config.yaml (or a fallback).
+agents_md_append_header() {
+    local output="$1"
+    local config_file="$2"
+
+    local header
+    header=$(get_target_block "$config_file" "agents" "header")
+
+    if [ -n "$header" ]; then
+        printf '%s\n' "$header" >> "$output"
+    else
+        local project_name
+        project_name=$(get_project_name "$config_file")
+        echo "# ${project_name:-Project}" >> "$output"
+    fi
+    echo "" >> "$output"
+}
+
+agents_md_append_agents_table() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output="$3"
+
+    local rows=""
+    local count=0
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        # Byte-order (LC_ALL=C) sort so generated output is identical across
+        # platforms — bash glob order follows LC_COLLATE, which differs between
+        # Linux CI (UTF-8, ignores `-`) and Git Bash (C, byte order).
+        while IFS= read -r f; do
+            [ -f "$f" ] || continue
+            local name rel tier access desc
+            name="$(basename "$f" .md)"
+            rel="$(repo_rel_link "$repo_root" "$f")"
+            tier=$(get_frontmatter_value "tier" "$f")
+            access=$(get_frontmatter_value "access" "$f")
+            desc=$(get_frontmatter_value "description" "$f")
+            if [ -n "$rel" ]; then
+                rows+="| [$name]($rel) | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
+            else
+                rows+="| $name | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
+            fi
+            count=$((count + 1))
+        done < <(find "$dir" -maxdepth 1 -type f -name '*.md' -print | LC_ALL=C sort)
+    done < <(read_yaml_list "$config_file" "agents")
+
+    [ "$count" -eq 0 ] && return 0
+
+    {
+        echo "### Agents"
+        echo ""
+        echo "| Agent | Tier | Access | Description |"
+        echo "|-------|------|--------|-------------|"
+        printf '%s' "$rows"
+        echo ""
+    } >> "$output"
+
+    echo "  agents: $count listed"
+}
+
+agents_md_append_skills_table() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output="$3"
+
+    local rows=""
+    local count=0
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        # Byte-order (LC_ALL=C) sort so generated output is identical across
+        # platforms — see the note in agents_md_append_agents_table.
+        while IFS= read -r skill_dir; do
+            [ -d "$skill_dir" ] || continue
+            local dirname
+            dirname="$(basename "$skill_dir")"
+            case "$dirname" in _*) continue ;; esac
+            local skill_file="${skill_dir%/}/SKILL.md"
+            [ -f "$skill_file" ] || continue
+            local rel desc
+            rel="$(repo_rel_link "$repo_root" "$skill_file")"
+            desc=$(get_frontmatter_value "description" "$skill_file")
+            if [ -n "$rel" ]; then
+                rows+="| [$dirname]($rel) | ${desc:--} |"$'\n'
+            else
+                rows+="| $dirname | ${desc:--} |"$'\n'
+            fi
+            count=$((count + 1))
+        done < <(find "$dir" -mindepth 1 -maxdepth 1 -type d -print | LC_ALL=C sort)
+    done < <(read_yaml_list "$config_file" "skills")
+
+    [ "$count" -eq 0 ] && return 0
+
+    {
+        echo "### Skills"
+        echo ""
+        echo "| Skill | Description |"
+        echo "|-------|-------------|"
+        printf '%s' "$rows"
+        echo ""
+    } >> "$output"
+
+    echo "  skills: $count listed"
+}
+
+agents_md_append_rules_list() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output="$3"
+
+    local lines=""
+    local count=0
+    local global_rule_files=()
+
+    while IFS= read -r src; do
+        [ -z "$src" ] && continue
+        local dir
+        dir="$(resolve_source_dir "$repo_root" "$src")"
+        [ -d "$dir" ] || continue
+        # Byte-order (LC_ALL=C) sort so generated output — and the inline order
+        # of always-on rules below — is identical across platforms. See the
+        # note in agents_md_append_agents_table.
+        while IFS= read -r f; do
+            [ -f "$f" ] || continue
+            local name rel scope
+            name="$(basename "$f" .md)"
+            rel="$(repo_rel_link "$repo_root" "$f")"
+            scope="global"
+            if [ "$(has_paths "$f")" != "0" ]; then
+                scope="scoped"
+            else
+                global_rule_files+=("$f")
+            fi
+            if [ -n "$rel" ]; then
+                lines+="- [$name]($rel) ($scope)"$'\n'
+            else
+                lines+="- $name ($scope)"$'\n'
+            fi
+            count=$((count + 1))
+        done < <(find "$dir" -maxdepth 1 -type f -name '*.md' -print | LC_ALL=C sort)
+    done < <(read_yaml_list "$config_file" "rules")
+
+    [ "$count" -eq 0 ] && return 0
+
+    {
+        echo "### Rules"
+        echo ""
+        printf '%s' "$lines"
+        echo ""
+    } >> "$output"
+
+    echo "  rules: $count listed"
+
+    # Always-on rules (no `paths:`) are inlined into AGENTS.md as canonical
+    # project context. Codex (only reads AGENTS.md) and Cursor/Copilot
+    # (read AGENTS.md natively) all pick up rule content from here.
+    # Path-scoped rules stay in tool-specific channels (.cursor/rules/,
+    # .github/instructions/) so monorepo scoping is preserved.
+    if [ "${#global_rule_files[@]}" -gt 0 ]; then
+        local umbrella_rel
+        umbrella_rel="$(agents_md_umbrella_rel "$repo_root")"
+        {
+            echo "---"
+            echo ""
+            echo "## Project Context"
+            echo ""
+            echo "<!-- Inlined from always-on rules in $umbrella_rel/rules/ -->"
+            echo ""
+        } >> "$output"
+        local rf
+        for rf in "${global_rule_files[@]}"; do
+            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 }
+            ' "$rf" >> "$output"
+            echo "" >> "$output"
+        done
+        echo "  rules: ${#global_rule_files[@]} global rule(s) inlined"
+    fi
+}
+
+# Main entry point for AGENTS.md adapter
+sync_to_agents() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== AGENTS.md ==="
+
+    # output_dir points at the target file path (e.g., /repo/AGENTS.md).
+    # If it looks like a directory (trailing slash, existing dir, or no .md
+    # extension), append default filename.
+    local output_file="$output_dir"
+    if [ -d "$output_file" ] || [[ "$output_file" == */ ]] || [[ "$output_file" != *.md ]]; then
+        output_file="${output_file%/}/AGENTS.md"
+    fi
+
+    mkdir -p "$(dirname "$output_file")"
+
+    local umbrella_rel module_rel
+    umbrella_rel="$(agents_md_umbrella_rel "$repo_root")"
+    module_rel="$(agents_md_module_rel "$repo_root")"
+
+    # These two strings are written into a COMMITTED file. An absolute path here
+    # means the derivation failed, and a machine-specific path in AGENTS.md is
+    # worse than a failed sync — fail loudly instead.
+    case "$umbrella_rel$module_rel" in
+        /*|*:[\\/]*)
+            echo "  ERROR: AGENTS.md paths did not resolve relative to the repo root:" >&2
+            echo "         umbrella='$umbrella_rel' module='$module_rel' repo_root='$repo_root'" >&2
+            return 1
+            ;;
+    esac
+
+    # How a reader re-runs the sync: the CLI names its own command (IS_SYNC_CMD),
+    # a vendored setup gets the script invocation.
+    local sync_cmd="${IS_SYNC_CMD:-bash $module_rel/scripts/sync.sh}"
+
+    {
+        echo "<!-- Generated by intelligence-sync. Do not edit manually. -->"
+        echo "<!-- Source: $umbrella_rel/ | Sync: $sync_cmd -->"
+        echo ""
+    } > "$output_file"
+
+    agents_md_append_header "$output_file" "$config_file"
+
+    {
+        echo "## Intelligence"
+        echo ""
+        echo "Source of truth: \`$umbrella_rel/\` | Sync: \`$sync_cmd\`"
+        echo ""
+    } >> "$output_file"
+
+    agents_md_append_agents_table "$repo_root" "$config_file" "$output_file"
+    agents_md_append_skills_table "$repo_root" "$config_file" "$output_file"
+    agents_md_append_rules_list  "$repo_root" "$config_file" "$output_file"
+
+    finalize_output_file "$output_file"
+
+    # Safety net: AGENTS.md is committed, so it must never carry an absolute or
+    # transient link target (remote-pack content lives under the run cache). If
+    # relativization ever fails, fail the sync loudly rather than write a
+    # machine-specific path into version control.
+    if grep -nE '\]\((/|[A-Za-z]:[\\/])' "$output_file" >/dev/null 2>&1; then
+        echo "  ERROR: AGENTS.md has an absolute link target — relativization failed:" >&2
+        grep -nE '\]\((/|[A-Za-z]:[\\/])' "$output_file" >&2
+        return 1
+    fi
+
+    echo "  -> ${output_file#$repo_root/}"
+}

package/engine/scripts/adapters/claude.sh

@@ -0,0 +1,136 @@
+#!/bin/bash
+# intelligence-sync: Claude Code adapter
+# Transforms source prompts to .claude/ format
+#
+# Rules: copy as-is (paths: frontmatter preserved)
+# Skills: copy skill directories in full (SKILL.md + bundled resources)
+# Agents: tier -> model, access -> tools/disallowedTools
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Sync rules to Claude format (copy as-is, normalize LF)
+sync_claude_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
+            cp "$f" "$output_dir/rules/"
+            finalize_output_file "$output_dir/rules/$(basename "$f")"
+            echo "  rule: $(basename "$f")"
+        done
+    done < <(read_yaml_list "$config_file" "rules")
+}
+
+# Sync skills to Claude format (copy skill directories in full)
+sync_claude_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 a single agent file to Claude format
+sync_claude_agent() {
+    local src="$1"
+    local config_file="$2"
+    local output_dir="$3"
+    local name
+    name="$(basename "$src")"
+
+    local tier access
+    tier=$(get_frontmatter_value "tier" "$src")
+    access=$(get_frontmatter_value "access" "$src")
+
+    local model tools extra
+    model=$(get_model "$config_file" "claude" "$tier")
+    tools=$(map_access_to_claude_tools "$access")
+    extra=$(map_access_to_claude_disallowed "$access")
+
+    # Transform: remove tier/access, inject tools/model/disallowedTools before closing ---
+    awk -v model="$model" -v tools="$tools" -v extra="$extra" '
+        BEGIN { count=0 }
+        /^tier:/  { next }
+        /^access:/ { next }
+        {
+            sub(/\r$/, "")
+        }
+        /^---$/ { count++ }
+        count==2 && /^---$/ {
+            if (tools != "") print "tools: " tools
+            if (extra != "") print "disallowedTools: " extra
+            print "model: " model
+        }
+        { print }
+    ' "$src" > "$output_dir/agents/$name"
+    finalize_output_file "$output_dir/agents/$name"
+    echo "  agent: $name (tier=$tier -> model=$model, access=$access)"
+}
+
+# Sync all agents to Claude format
+sync_claude_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
+            sync_claude_agent "$f" "$config_file" "$output_dir"
+        done
+    done < <(read_yaml_list "$config_file" "agents")
+}
+
+# Main entry point for Claude adapter
+sync_to_claude() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== Claude Code ==="
+
+    # Clean generated content only — preserve any project-level files
+    # the user manages directly (settings.json, settings.local.json,
+    # commands/, statusline.sh, etc.).
+    rm -rf "$output_dir/rules" "$output_dir/agents"
+    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
+    mkdir -p "$output_dir/rules" "$output_dir/skills" "$output_dir/agents"
+
+    sync_claude_rules "$repo_root" "$config_file" "$output_dir"
+    sync_claude_skills "$repo_root" "$config_file" "$output_dir"
+    sync_claude_agents "$repo_root" "$config_file" "$output_dir"
+
+    local rules_count skills_count agents_count
+    rules_count=$(find "$output_dir/rules" -name "*.md" 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, Skills: $skills_count, Agents: $agents_count"
+}

package/engine/scripts/adapters/codex.sh

@@ -0,0 +1,118 @@
+#!/bin/bash
+# intelligence-sync: OpenAI Codex CLI adapter
+# Transforms source prompts to Codex format.
+#
+# Codex reads AGENTS.md natively for project context — the `agents` adapter
+# inlines always-on rules into AGENTS.md, so this adapter only emits skills
+# and subagent definitions.
+#
+# Skills: copy skill directories in full to .agents/skills/{name}/ (Codex
+#   reads from $REPO_ROOT/.agents/skills exclusively per official docs)
+# Agents: -> .codex/agents/{name}.toml (name, description, model,
+#   model_reasoning_effort, sandbox_mode, developer_instructions)
+
+source "$(dirname "${BASH_SOURCE[0]}")/../lib/common.sh"
+
+# Sync skills to Codex format (.agents/skills/{name}/SKILL.md)
+sync_codex_skills() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    sync_open_skill_dirs "$repo_root" "$config_file" "$output_dir"
+}
+
+# Sync agents to Codex format (.codex/agents/{name}.toml)
+sync_codex_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 effort sandbox
+            model=$(get_model "$config_file" "codex" "$tier")
+            case "$tier" in
+                heavy)    effort="high" ;;
+                standard) effort="medium" ;;
+                light)    effort="low" ;;
+                *)        effort="medium" ;;
+            esac
+            case "$access" in
+                readonly) sandbox="read-only" ;;
+                *)        sandbox="workspace-write" ;;
+            esac
+
+            local body
+            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")
+
+            # Escape backslashes used in Markdown paths, then neutralize any
+            # closing TOML triple-quote sequence in the agent body.
+            local body_safe
+            body_safe="${body//\\/\\\\}"
+            body_safe="${body_safe//\"\"\"/\"\"\\\"}"
+
+            local name_escaped description_escaped
+            name_escaped=$(toml_escape "$name")
+            description_escaped=$(toml_escape "$description")
+
+            {
+                echo "name = \"$name_escaped\""
+                echo "description = \"$description_escaped\""
+                echo "model = \"$model\""
+                echo "model_reasoning_effort = \"$effort\""
+                echo "sandbox_mode = \"$sandbox\""
+                echo ""
+                echo "developer_instructions = \"\"\""
+                echo "$body_safe"
+                echo "\"\"\""
+            } > "$output_dir/$name.toml"
+            finalize_output_file "$output_dir/$name.toml"
+            count=$((count + 1))
+            echo "  agent: $name.toml"
+        done
+    done < <(read_yaml_list "$config_file" "agents")
+
+    echo "  -> Agents: $count"
+}
+
+# Main entry point for Codex adapter
+sync_to_codex() {
+    local repo_root="$1"
+    local config_file="$2"
+    local output_dir="$3"
+
+    echo "=== OpenAI Codex ==="
+
+    # Skills -> .agents/skills/ (Codex reads from this fixed path).
+    # `sync_open_skill_dirs` owns clean + populate of this shared dir.
+    local skills_dir="$repo_root/.agents/skills"
+    sync_codex_skills "$repo_root" "$config_file" "$skills_dir"
+
+    # Agents -> .codex/agents/
+    local agents_dir="$repo_root/.codex/agents"
+    rm -rf "$agents_dir"
+    mkdir -p "$agents_dir"
+    sync_codex_agents "$repo_root" "$config_file" "$agents_dir"
+}