@ainova-systems/intelligence 0.16.0 → 0.16.1

package/cli/lib/gitignore.sh

@@ -1,12 +1,56 @@
 #!/bin/bash
 # Generated-output policy derived from each adapter's ownership contract.
 
+# The line that separates what this policy manages from what the project wrote
+# before Intelligence touched the file: everything the CLI appends lands after
+# it, so it is also the boundary of what the CLI may rewrite.
+IS_GITIGNORE_HEADER='# Intelligence generated state and tool output'
+
+# Line endings held in variables, never written as `$'\r'` at the point of use:
+# inside a command substitution bash does not expand that form, so the very same
+# expression stops stripping the CR depending on where it is called from.
+IS_CR=$'\r'
+IS_LF=$'\n'
+IS_CRLF=$'\r\n'
+
+# An ignore file checked out on Windows can hold CRLF, and a CR belongs to the
+# pattern Git matches — so these two helpers decide presence ignoring it, and
+# append in whatever ending the file already uses. Comparing with the CR
+# attached made every existing line look absent on Linux and macOS (where it is
+# part of the line, unlike under MSYS), so each alignment appended an LF copy of
+# a line that was already there and the file grew forever.
+
+# ignore_file_eol_var <file> — set IS_IGNORE_EOL from the file's first line.
+ignore_file_eol_var() {
+    local file="$1" first=""
+    IS_IGNORE_EOL="$IS_LF"
+    [ -s "$file" ] || return 0
+    IFS= read -r first < "$file" || true
+    case "$first" in
+        *"$IS_CR") IS_IGNORE_EOL="$IS_CRLF" ;;
+    esac
+}
+
+# ignore_file_has_line <file> <line> — true when the file lists exactly this
+# line, with or without a trailing CR.
+ignore_file_has_line() {
+    local file="$1" line="$2"
+    [ -f "$file" ] || return 1
+    grep -Fqx -- "$line" "$file" 2>/dev/null && return 0
+    grep -Fqx -- "$line$IS_CR" "$file" 2>/dev/null
+}
+
+# ignore_file_append_line <file> <line> — append in the file's own ending.
+ignore_file_append_line() {
+    local file="$1" line="$2"
+    ignore_file_eol_var "$file"
+    printf '%s%s' "$line" "$IS_IGNORE_EOL" >> "$file"
+}
+
 gitignore_add_line() {
     local root="$1" line="$2" file="$1/.gitignore"
-    if [ -f "$file" ] && grep -Fqx -- "$line" "$file"; then
-        return 0
-    fi
-    printf '%s\n' "$line" >> "$file"
+    ignore_file_has_line "$file" "$line" && return 0
+    ignore_file_append_line "$file" "$line"
 }
 
 gitignore_path_is_ignored() {
@@ -21,10 +65,102 @@ gitignore_tail_is() {
     [ -f "$file" ] || return 1
     local want tail_lines
     want="$(printf '%s\n' "$@")"
-    tail_lines="$(tail -n "$#" -- "$file")"
+    # CR stripped for the comparison only — the chain is the same chain whether
+    # the file is LF or CRLF.
+    tail_lines="$(tail -n "$#" -- "$file" | tr -d '\r')"
     [ "$tail_lines" = "$want" ]
 }
 
+# gitignore_collapse_duplicates <root> <probe-path> <line…> — keep only the LAST
+# occurrence of each given line inside the region this policy owns (its header
+# to end of file).
+#
+# This removes residue, never meaning: Git applies the last matching rule, so
+# identical earlier copies of a line decide nothing. The copies exist because
+# the 0.12.0 repair appended the whole negation chain on every alignment — a
+# project carries one chain per run it made, and 0.12.1 only stopped the growth.
+#
+# Lines above the header predate Intelligence and are left untouched, including
+# a hand-written copy of a line this policy also writes. The probe path is
+# re-checked afterwards: a collapse that somehow changed what Git ignores is
+# rolled back rather than committed.
+gitignore_collapse_duplicates() {
+    local root="$1" probe="$2"; shift 2
+    local file="$root/.gitignore" tmp backup before=0 after=0
+    local -a lines=() managed=("$@") last_idx=()
+    local line key i mi n hdr=-1 keep final_newline=1
+    [ -f "$file" ] || return 0
+
+    # Read and write the file's own bytes, without awk: on Windows it reads in
+    # text mode and would hand back every line stripped of its CR, rewriting a
+    # CRLF file as LF. A line's CR is significant to Git, and either way the
+    # lines this function does not remove must survive byte-for-byte.
+    line=""
+    while IFS= read -r line; do
+        lines[${#lines[@]}]="$line"
+        line=""
+    done < "$file"
+    # `read` returns 1 at EOF but still fills `line` when the file's last line
+    # carries no newline; preserve that ending instead of adding one.
+    if [ -n "$line" ]; then
+        lines[${#lines[@]}]="$line"
+        final_newline=0
+    fi
+    n=${#lines[@]}
+    for ((i = 0; i < n; i++)); do
+        if [ "${lines[i]%"$IS_CR"}" = "$IS_GITIGNORE_HEADER" ]; then hdr=$i; break; fi
+    done
+    [ "$hdr" -ge 0 ] || return 0
+
+    # Where each managed line last occurs below the header. Indexed arrays and
+    # arithmetic `for` only — Bash 3.2 has no associative arrays.
+    for ((mi = 0; mi < ${#managed[@]}; mi++)); do
+        last_idx[mi]=-1
+        for ((i = hdr + 1; i < n; i++)); do
+            [ "${lines[i]%"$IS_CR"}" = "${managed[mi]}" ] && last_idx[mi]=$i
+        done
+    done
+
+    tmp="$file.cli.tmp"
+    {
+        for ((i = 0; i < n; i++)); do
+            keep=1
+            if [ "$i" -gt "$hdr" ]; then
+                key="${lines[i]%"$IS_CR"}"
+                for ((mi = 0; mi < ${#managed[@]}; mi++)); do
+                    if [ "$key" = "${managed[mi]}" ] && [ "$i" -ne "${last_idx[mi]}" ]; then
+                        keep=0
+                        break
+                    fi
+                done
+            fi
+            [ "$keep" -eq 1 ] || continue
+            if [ "$i" -eq $((n - 1)) ] && [ "$final_newline" -eq 0 ]; then
+                printf '%s' "${lines[i]}"
+            else
+                printf '%s\n' "${lines[i]}"
+            fi
+        done
+    } > "$tmp"
+    if [ ! -s "$tmp" ] || cmp -s "$tmp" "$file"; then
+        rm -f "$tmp"
+        return 0
+    fi
+
+    before=0
+    gitignore_path_is_ignored "$root" "$probe" || before=$?
+    backup="$file.cli.bak"
+    cp -- "$file" "$backup"
+    mv -- "$tmp" "$file"
+    after=0
+    gitignore_path_is_ignored "$root" "$probe" || after=$?
+    if [ "$after" != "$before" ]; then
+        mv -- "$backup" "$file"
+        return 0
+    fi
+    rm -f "$backup"
+}
+
 # Git cannot re-include a child of an excluded directory, so an include needs an
 # explicit negation for every parent. A negation only wins when it comes after
 # the rule excluding the parent, and the only repair an append can make is to
@@ -59,7 +195,7 @@ gitignore_add_effective_include() {
     gitignore_path_is_ignored "$root" "$value" || rc=$?
     case "$rc" in
         0) ;;
-        1|2) return 0 ;;
+        1|2) gitignore_collapse_duplicates "$root" "$value" "${negations[@]}"; return 0 ;;
         *) return "$rc" ;;
     esac
 
@@ -67,17 +203,25 @@ gitignore_add_effective_include() {
     # chain last. Already last means appending cannot help — leave it, and let
     # `status --check` report the re-inclusion this policy could not make
     # effective rather than growing the file forever.
-    gitignore_tail_is "$root/.gitignore" "${negations[@]}" && return 0
-    printf '%s\n' "${negations[@]}" >> "$root/.gitignore"
+    if ! gitignore_tail_is "$root/.gitignore" "${negations[@]}"; then
+        for line in "${negations[@]}"; do
+            ignore_file_append_line "$root/.gitignore" "$line"
+        done
+    fi
+    # Either way the chain now stands last, so any earlier copy of it is the
+    # residue an older CLI appended; collapsing runs on both paths so a project
+    # converges on one copy whether or not this run had to move anything.
+    gitignore_collapse_duplicates "$root" "$value" "${negations[@]}"
 }
 
 ensure_gitignore_header() {
     local root="$1" file="$1/.gitignore"
-    if [ ! -f "$file" ] || ! grep -Fqx '# Intelligence generated state and tool output' "$file"; then
+    if ! ignore_file_has_line "$file" "$IS_GITIGNORE_HEADER"; then
         if [ -f "$file" ] && [ -s "$file" ] && [ -n "$(tail -c 1 "$file" 2>/dev/null)" ]; then
-            printf '\n' >> "$file"
+            ignore_file_eol_var "$file"
+            printf '%s' "$IS_IGNORE_EOL" >> "$file"
         fi
-        printf '%s\n' '# Intelligence generated state and tool output' >> "$file"
+        ignore_file_append_line "$file" "$IS_GITIGNORE_HEADER"
     fi
 }
 
@@ -125,10 +269,8 @@ publisher_ignore_file_names() {
 
 publisher_ignore_add_line() {
     local file="$1" line="$2"
-    if grep -Fqx -- "$line" "$file" 2>/dev/null; then
-        return 0
-    fi
-    printf '%s\n' "$line" >> "$file"
+    ignore_file_has_line "$file" "$line" && return 0
+    ignore_file_append_line "$file" "$line"
     PUBLISH_IGNORE_FILE_CHANGED=1
 }
 
@@ -148,11 +290,12 @@ ensure_manifest_publisher_ignores() {
         file="$root/$rel"
         [ -f "$file" ] || continue
         PUBLISH_IGNORE_FILE_CHANGED=0
-        if ! grep -Fqx '# Intelligence development context and generated output' "$file" 2>/dev/null; then
+        if ! ignore_file_has_line "$file" '# Intelligence development context and generated output'; then
             if [ -s "$file" ] && [ -n "$(tail -c 1 "$file" 2>/dev/null)" ]; then
-                printf '\n' >> "$file"
+                ignore_file_eol_var "$file"
+                printf '%s' "$IS_IGNORE_EOL" >> "$file"
             fi
-            printf '%s\n' '# Intelligence development context and generated output' >> "$file"
+            ignore_file_append_line "$file" '# Intelligence development context and generated output'
             PUBLISH_IGNORE_FILE_CHANGED=1
         fi
         publisher_ignore_add_path "$file" '.intelligence'

package/engine/ENGINE_SHA

@@ -1 +1 @@
-179b1e89ade2ac7d833750458de1babe0c7a6d90
+365ec21e2f2d4d9ef323ed9f1387b3c3c4bef845

package/engine/VERSION

@@ -1 +1 @@
-0.16.0
+0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Build, version and distribute AI agent intelligence across your organization — one CLI, versioned Intelligence Packages, and a sync engine for Claude Code, Cursor, Copilot, Codex, Pi and OpenCode.",
   "bin": {
     "intelligence": "bin/intelligence.js"