@drafthq/draft 2.7.0

package/scripts/tools/mermaid-from-graph.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# mermaid-from-graph.sh — emit Mermaid diagrams from the knowledge graph.
+#
+# Backed by the codebase-memory-mcp engine. Two diagrams:
+#   module-deps : file co-change coupling (FILE_CHANGES_WITH edges) as a flowchart.
+#   proto-map   : detected service routes (Route nodes) as a flowchart.
+#
+# When the engine is unavailable, emits an empty diagram stub and exits 2 so
+# consuming skills can degrade gracefully.
+#
+# Usage:
+#   scripts/tools/mermaid-from-graph.sh [--repo DIR] [--diagram module-deps|proto-map]
+#
+# Exit codes: 0 OK, 1 invocation error, 2 graph engine/data unavailable.
+set -euo pipefail
+
+# shellcheck source=_lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_lib.sh"
+
+REPO="."
+DIAGRAM="module-deps"
+
+usage() {
+    cat <<'EOF'
+mermaid-from-graph.sh — emit Mermaid diagrams from the knowledge graph.
+
+Usage:
+  scripts/tools/mermaid-from-graph.sh [--repo DIR] [--diagram module-deps|proto-map]
+
+Flags:
+  --repo DIR      Repository root (default: cwd).
+  --diagram NAME  module-deps (default) or proto-map.
+  --help          Show this help.
+
+Exit 0 with diagram output, exit 2 with an empty stub when the engine is unavailable.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --diagram) DIAGRAM="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+if [[ ! -d "$REPO" ]]; then
+    echo "ERROR: --repo '$REPO' is not a directory" >&2
+    exit 1
+fi
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+stub() {
+    cat <<'EOF'
+```mermaid
+%% graph data unavailable — index the repo with the graph engine first
+flowchart LR
+    empty["graph not built"]
+```
+EOF
+    exit 2
+}
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || stub
+command -v jq >/dev/null 2>&1 || stub
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || stub
+
+render_module_deps() {
+    local q="MATCH (a:File)-[r:FILE_CHANGES_WITH]->(b:File) RETURN a.name AS src, b.name AS dst, r.coupling_score AS score ORDER BY r.coupling_score DESC LIMIT 40"
+    local res; res="$(memory_cli query_graph "{\"project\":\"$PROJECT\",\"query\":\"$q\"}" || echo '{}')"
+    local edges; edges="$(echo "${res:-{\}}" | jq -r '(.rows // [])[] | "    \"" + (.[0]|tostring) + "\" --> \"" + (.[1]|tostring) + "\""' 2>/dev/null || true)"
+    if [[ -z "$edges" ]]; then return 1; fi
+    printf '```mermaid\nflowchart LR\n%s\n```\n' "$edges"
+}
+
+render_proto_map() {
+    local res; res="$(memory_cli get_architecture "{\"project\":\"$PROJECT\",\"aspects\":[\"routes\"]}" || echo '{}')"
+    local edges; edges="$(echo "${res:-{\}}" | jq -r '(.routes // [])[] | "    \"" + ((.method // "")|tostring) + " " + ((.path // "")|tostring) + "\" --> \"" + ((.handler // "?")|tostring) + "\""' 2>/dev/null || true)"
+    if [[ -z "$edges" ]]; then return 1; fi
+    printf '```mermaid\nflowchart LR\n%s\n```\n' "$edges"
+}
+
+case "$DIAGRAM" in
+    module-deps) render_module_deps || stub ;;
+    proto-map)   render_proto_map || stub ;;
+    *) echo "Unknown --diagram '$DIAGRAM' (expected module-deps|proto-map)" >&2; exit 1 ;;
+esac

package/scripts/tools/migrate-track-frontmatter.sh

@@ -0,0 +1,241 @@
+#!/usr/bin/env bash
+# migrate-track-frontmatter.sh
+#
+# Idempotent rewriter that migrates a pre-2.0 Draft track to the WS-8
+# metadata-as-source-of-truth shape:
+#
+# - Strips ephemeral fields from per-file YAML frontmatter in spec.md,
+# hld.md, lld.md, plan.md: `git.*`, `synced_to_commit`, `classification.*`,
+# `status`, `scope_includes`, `scope_excludes`.
+# - Promotes them into metadata.json (creating fields if absent; preserving
+# existing values).
+# - Markdown frontmatter retains only: project, module, track_id,
+# generated_by, generated_at, links.
+#
+# Idempotent: re-running on a 2.0 track produces zero diff.
+# Safe: emits <file>.bak alongside each rewritten file unless --no-backup.
+#
+# Usage:
+# scripts/tools/migrate-track-frontmatter.sh tracks/foo
+# scripts/tools/migrate-track-frontmatter.sh --dry-run tracks/foo
+# scripts/tools/migrate-track-frontmatter.sh --no-backup tracks/foo
+#
+# Exit codes:
+# 0 success or no-op
+# 1 migration error
+# 2 usage / runtime error
+
+set -euo pipefail
+
+if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
+    echo "${0##*/} — Foundations quality tool (see core/ docs for full behavior)"
+    exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "$SCRIPT_DIR/_lib.sh"
+
+DRY_RUN=0
+BACKUP=1
+TRACK_DIRS=()
+
+usage() {
+    local stream=2 code=2
+    if [[ "${USAGE_HELP_MODE:-0}" == 1 ]]; then stream=1; code=0; fi
+    sed -n '2,22p' "$0" >&$stream
+    exit "$code"
+}
+
+while (($#)); do
+    case "$1" in
+        -h|--help) USAGE_HELP_MODE=1 usage ;;
+        --dry-run) DRY_RUN=1; shift ;;
+        --no-backup) BACKUP=0; shift ;;
+        -*) printf 'Unknown flag: %s\n' "$1" >&2; usage ;;
+        *) TRACK_DIRS+=("$1"); shift ;;
+    esac
+done
+
+(( ${#TRACK_DIRS[@]} == 0 )) && usage
+
+# Ephemeral keys to strip from per-file YAML frontmatter.
+EPHEMERAL_KEYS=(
+    "git"
+    "synced_to_commit"
+    "classification"
+    "status"
+    "scope_includes"
+    "scope_excludes"
+)
+
+# Stable keys that survive in markdown frontmatter.
+STABLE_KEYS=(
+    "project"
+    "module"
+    "track_id"
+    "generated_by"
+    "generated_at"
+    "links"
+)
+
+# Strip ephemeral blocks from a markdown file's YAML frontmatter.
+# Approach: read the file; rewrite the frontmatter section so any line whose
+# first token (before colon) matches an ephemeral key — plus any indented
+# continuation lines — is dropped.
+strip_frontmatter() {
+    local file="$1"
+    awk -v ephemeral_re="^($(IFS='|'; echo "${EPHEMERAL_KEYS[*]}"))(:|[[:space:]])" '
+        BEGIN { state = "before"; skip = 0 }
+        state == "before" {
+            print
+            if ($0 == "---") state = "in_fm"
+            next
+        }
+        state == "in_fm" {
+            if ($0 == "---") { state = "after"; print; skip = 0; next }
+            # Detect a top-level ephemeral key: starts at column 1.
+            if ($0 ~ ephemeral_re && $0 !~ /^[[:space:]]/) {
+                skip = 1
+                next
+            }
+            # Indented continuation lines belong to the previous block.
+            if (skip == 1 && $0 ~ /^[[:space:]]/) { next }
+            # Non-indented line — end of any previous ephemeral block.
+            skip = 0
+            print
+            next
+        }
+        state == "after" { print }
+    ' "$file"
+}
+
+# Promote a JSON field into metadata.json at the top level if it does not
+# already exist. Prefers Python for robust JSON manipulation; falls back to
+# awk for environments without Python.
+#
+# The awk fallback inserts before the FIRST line that is a bare "}" with no
+# leading whitespace, which is the outer object's close. The previous
+# implementation matched any "}" line and risked inserting fields into
+# nested objects (e.g. inside `impact`).
+ensure_meta_field() {
+    local meta="$1" key="$2" default_value="$3"
+    if grep -Eq "^[[:space:]]*\"$key\"[[:space:]]*:" "$meta"; then
+        return 0
+    fi
+    if command -v python3 >/dev/null 2>&1; then
+        python3 - "$meta" "$key" "$default_value" <<'PY'
+import json, sys, ast, tempfile, os
+path, key, raw = sys.argv[1], sys.argv[2], sys.argv[3]
+with open(path) as f:
+    data = json.load(f)
+if key in data:
+    sys.exit(0)
+# Parse the default value: try JSON first (handles [], {}, true, numbers,
+# quoted strings); fall back to literal string on failure.
+try:
+    value = json.loads(raw)
+except Exception:
+    value = raw.strip('"')
+data[key] = value
+fd, tmp = tempfile.mkstemp(dir=os.path.dirname(path) or ".")
+with os.fdopen(fd, "w") as f:
+    json.dump(data, f, indent=2)
+    f.write("\n")
+os.replace(tmp, path)
+PY
+    else
+        # awk fallback: insert before the LAST line that is a closing `}` at
+        # column 1. That is the outer object's closing brace.
+        awk -v key="$key" -v val="$default_value" '
+            { lines[NR] = $0 }
+            END {
+                # Find last bare-} line.
+                last_brace = 0
+                for (i = NR; i > 0; i--) {
+                    if (lines[i] == "}") { last_brace = i; break }
+                }
+                for (i = 1; i <= NR; i++) {
+                    if (i == last_brace) {
+                        # Inject before the close.
+                        # Ensure previous content line ends with a comma.
+                        if (i > 1) {
+                            prev = lines[i - 1]
+                            sub(/[[:space:]]*$/, "", prev)
+                            if (prev !~ /[,{[]$/) prev = prev ","
+                            lines[i - 1] = prev
+                        }
+                        print " \"" key "\": " val
+                    }
+                    print lines[i]
+                }
+            }
+        ' "$meta" > "${meta}.tmp" && mv "${meta}.tmp" "$meta"
+    fi
+}
+
+migrate_one_track() {
+    local track_dir="$1"
+    if [[ ! -d "$track_dir" ]]; then
+        printf 'migrate: not a directory: %s\n' "$track_dir" >&2
+        return 1
+    fi
+    track_dir="$(cd "$track_dir" && pwd)"
+
+    local meta="$track_dir/metadata.json"
+    if [[ ! -f "$meta" ]]; then
+        printf 'migrate: %s has no metadata.json — creating minimal\n' "$track_dir" >&2
+        if (( ! DRY_RUN )); then
+            cat > "$meta" <<EOF
+{
+  "id": "$(basename "$track_dir")",
+  "title": "_TBD_title_",
+  "type": "feature",
+  "status": "draft",
+  "template_version": "2.0.0",
+  "created": "_TBD_created_",
+  "updated": "_TBD_updated_",
+  "scope_includes": [],
+  "scope_excludes": [],
+  "phases": { "total": 0, "completed": 0 },
+  "tasks": { "total": 0, "completed": 0 }
+}
+EOF
+        fi
+    fi
+
+    if (( ! DRY_RUN )); then
+        ensure_meta_field "$meta" "template_version" '"2.0.0"'
+        ensure_meta_field "$meta" "scope_includes" '[]'
+        ensure_meta_field "$meta" "scope_excludes" '[]'
+        ensure_meta_field "$meta" "pre_deploy_status" '"unrun"'
+    fi
+
+    local changed=0
+    for f in spec.md hld.md lld.md plan.md discovery.md; do
+        local path="$track_dir/$f"
+        [[ -f "$path" ]] || continue
+        local before; before="$(cat "$path")"
+        local after; after="$(strip_frontmatter "$path")"
+        if [[ "$before" != "$after" ]]; then
+            changed=1
+            if (( DRY_RUN )); then
+                printf 'migrate: would strip ephemeral frontmatter from %s\n' "$path"
+            else
+                (( BACKUP )) && cp "$path" "$path.bak"
+                local _tmp; _tmp="$(mktemp "${path}.XXXXXX")"; printf '%s' "$after" > "$_tmp" && mv -f "$_tmp" "$path"
+                printf 'migrate: stripped ephemeral frontmatter from %s\n' "$path"
+            fi
+        fi
+    done
+
+    if (( changed == 0 )); then
+        printf 'migrate: %s already at 2.0 — no-op\n' "$track_dir"
+    fi
+}
+
+rc=0
+for t in "${TRACK_DIRS[@]}"; do
+    migrate_one_track "$t" || rc=$?
+done
+exit "$rc"

package/scripts/tools/parse-git-log.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# parse-git-log.sh — parse conventional commits into structured JSONL.
+#
+# Output one JSON object per commit:
+# {sha, type, scope, track_id, subject, author, timestamp, files_changed}
+#
+# Conventional commit subject: "type(scope): subject"
+# type may end in "!" to denote breaking change.
+#
+# track_id:
+# - extracted from the scope if it matches --scope-pattern (default none)
+# - OR from the subject if a literal `[TRACK-123]` / `(TRACK-123)` appears
+# - else null
+#
+# Usage:
+# scripts/tools/parse-git-log.sh [--since RANGE] [--limit N]
+# [--scope-pattern REGEX] [--branch REF]
+#
+# Exit codes: 0 OK, 1 invocation error.
+set -euo pipefail
+
+# shellcheck source=_lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_lib.sh"
+
+SINCE=""
+LIMIT=""
+SCOPE_PATTERN=""
+BRANCH="HEAD"
+
+usage() {
+    cat <<'EOF'
+parse-git-log.sh — parse conventional commits into JSONL.
+
+Usage:
+  scripts/tools/parse-git-log.sh [--since RANGE] [--limit N]
+                                 [--scope-pattern REGEX] [--branch REF]
+
+Flags:
+  --since RANGE Passed to git log --since (e.g. "7d", "2 weeks ago").
+  --limit N Max number of commits (git log -n N).
+  --scope-pattern RE Extended regex; if a commit's scope matches, it becomes the track_id.
+  --branch REF Branch/ref to inspect (default: HEAD).
+  --help Show this help.
+
+Output: JSONL with one record per commit.
+Fields: sha, type, scope, track_id, subject, author, timestamp, files_changed
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --since) SINCE="$2"; shift 2;;
+        --limit) LIMIT="$2"; shift 2;;
+        --scope-pattern) SCOPE_PATTERN="$2"; shift 2;;
+        --branch) BRANCH="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    echo "ERROR: not inside a git repository" >&2
+    exit 1
+fi
+
+# Format: delimiter-separated metadata line, then --name-only file list, blank line separator.
+GIT_ARGS=(log --pretty=tformat:'COMMIT%x1f%H%x1f%an%x1f%aI%x1f%s' --name-only --no-merges)
+[[ -n "$SINCE" ]] && GIT_ARGS+=(--since="$SINCE")
+[[ -n "$LIMIT" ]] && GIT_ARGS+=(-n "$LIMIT")
+GIT_ARGS+=("$BRANCH")
+
+# Read a commit block (metadata line + files) and emit one JSON record.
+process_commit() {
+    local sha="$1" author="$2" ts="$3" subject="$4" files_changed="$5"
+    local type scope breaking clean_subject cc_re track_id token inner scope_val
+    [[ -z "$sha" ]] && return
+
+    # Parse conventional commit: type(scope)!: subject OR type: subject
+    type="null"
+    scope="null"
+    breaking="false"
+    clean_subject="$subject"
+    cc_re='^([a-zA-Z]+)(\(([^)]+)\))?(!)?: (.+)$'
+    if [[ "$subject" =~ $cc_re ]]; then
+        type="\"${BASH_REMATCH[1]}\""
+        if [[ -n "${BASH_REMATCH[3]:-}" ]]; then
+            scope="\"$(json_escape "${BASH_REMATCH[3]}")\""
+        fi
+        [[ -n "${BASH_REMATCH[4]:-}" ]] && breaking="true"
+        clean_subject="${BASH_REMATCH[5]}"
+    fi
+
+    # Track ID detection
+    track_id="null"
+    if [[ -n "$SCOPE_PATTERN" && "$scope" != "null" ]]; then
+        scope_val="${scope#?}"
+        scope_val="${scope_val%?}" # strip surrounding quotes
+        if [[ "$scope_val" =~ $SCOPE_PATTERN ]]; then
+            track_id="\"$(json_escape "$scope_val")\""
+        fi
+    fi
+    # Look for [TRACK-XXX] or (TRACK-XXX) tokens in subject
+    if [[ "$track_id" == "null" ]]; then
+        token="$(printf '%s' "$clean_subject" | grep -oE '(\[[A-Z]+-[0-9]+\]|\([A-Z]+-[0-9]+\))' | head -1 || true)"
+        if [[ -n "$token" ]]; then
+            inner="${token#?}"
+            inner="${inner%?}"
+            track_id="\"$(json_escape "$inner")\""
+        fi
+    fi
+
+    printf '{"sha":"%s","type":%s,"scope":%s,"breaking":%s,"track_id":%s,"subject":"%s","author":"%s","timestamp":"%s","files_changed":%s}\n' \
+        "$sha" "$type" "$scope" "$breaking" "$track_id" \
+        "$(json_escape "$clean_subject")" \
+        "$(json_escape "$author")" \
+        "$ts" "$files_changed"
+}
+
+# Single git log stream: each commit is `COMMIT<US>sha<US>author<US>ts<US>subject`
+# followed by its file paths (one per line) and a blank separator.
+cur_sha=""; cur_author=""; cur_ts=""; cur_subject=""; cur_files=0
+while IFS= read -r line; do
+    if [[ "$line" == COMMIT$'\x1f'* ]]; then
+        if [[ -n "$cur_sha" ]]; then
+            process_commit "$cur_sha" "$cur_author" "$cur_ts" "$cur_subject" "$cur_files"
+        fi
+        IFS=$'\x1f' read -r _ cur_sha cur_author cur_ts cur_subject <<<"$line"
+        cur_files=0
+    elif [[ -n "$line" ]]; then
+        cur_files=$((cur_files + 1))
+    fi
+done < <(git "${GIT_ARGS[@]}")
+if [[ -n "$cur_sha" ]]; then
+    process_commit "$cur_sha" "$cur_author" "$cur_ts" "$cur_subject" "$cur_files"
+fi

package/scripts/tools/parse-reports.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# parse-reports.sh — parse Draft reports (bughunt/review/tech-debt/...) and emit a structured summary.
+#
+# For each `*-report-*.md` under --root, extract YAML frontmatter fields and
+# count severity markers in the report body.
+#
+# Output: JSON array of records:
+# {path, report_type, track_id, generated_at, severity:{critical,high,medium,low,info}}
+#
+# Usage:
+# scripts/tools/parse-reports.sh [--root DIR]
+#
+# Exit codes: 0 OK (even if no reports), 1 invocation error.
+set -euo pipefail
+
+# shellcheck source=_lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_lib.sh"
+
+ROOT="."
+
+usage() {
+    cat <<'EOF'
+parse-reports.sh — summarize Draft reports under a directory.
+
+Usage:
+  scripts/tools/parse-reports.sh [--root DIR]
+
+Flags:
+  --root DIR Directory to scan for *-report-*.md (default: cwd).
+  --help Show this help.
+
+Output: JSON array of {path, report_type, track_id, generated_at, severity}.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --root) ROOT="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+if [[ ! -d "$ROOT" ]]; then
+    echo "ERROR: --root '$ROOT' is not a directory" >&2
+    exit 1
+fi
+
+# Extract YAML frontmatter fields + severity counts in a single awk pass over each file.
+# Emits tab-separated: track_id<TAB>generated_at<TAB>critical<TAB>high<TAB>medium<TAB>low<TAB>info
+parse_report_fields() {
+    local file="$1"
+    awk '
+        BEGIN { in_fm = 0; past_fm = 0 }
+        NR == 1 && /^---$/ { in_fm = 1; next }
+        in_fm && /^---$/ { in_fm = 0; past_fm = 1; next }
+        in_fm {
+            if ($0 ~ /^track_id:[[:space:]]*/) {
+                v = $0; sub(/^track_id:[[:space:]]*/, "", v)
+                if (v ~ /^".*"$/) { v = substr(v, 2, length(v)-2) }
+                sub(/[[:space:]]+$/, "", v)
+                track_id = v
+            } else if ($0 ~ /^generated_at:[[:space:]]*/) {
+                v = $0; sub(/^generated_at:[[:space:]]*/, "", v)
+                if (v ~ /^".*"$/) { v = substr(v, 2, length(v)-2) }
+                sub(/[[:space:]]+$/, "", v)
+                generated_at = v
+            }
+            next
+        }
+        past_fm {
+            # Lowercase copy for severity detection.
+            l = tolower($0)
+            if (l ~ /(^|[^a-z])(severity:[[:space:]]*critical|\|[[:space:]]*critical[[:space:]]*\||^-[[:space:]]+critical:)/) crit++
+            if (l ~ /(^|[^a-z])(severity:[[:space:]]*high|\|[[:space:]]*high[[:space:]]*\||^-[[:space:]]+high:)/) high++
+            if (l ~ /(^|[^a-z])(severity:[[:space:]]*medium|\|[[:space:]]*medium[[:space:]]*\||^-[[:space:]]+medium:)/) med++
+            if (l ~ /(^|[^a-z])(severity:[[:space:]]*low|\|[[:space:]]*low[[:space:]]*\||^-[[:space:]]+low:)/) low++
+            if (l ~ /(^|[^a-z])(severity:[[:space:]]*info|\|[[:space:]]*info[[:space:]]*\||^-[[:space:]]+info:)/) info++
+        }
+        END {
+            printf "%s\t%s\t%d\t%d\t%d\t%d\t%d", track_id, generated_at, crit+0, high+0, med+0, low+0, info+0
+        }
+    ' "$file"
+}
+
+first=true
+printf '['
+while IFS= read -r -d '' file; do
+    base="$(basename "$file")"
+    report_type=""
+    if [[ "$base" =~ ^([a-z][a-z0-9-]+)-report- ]]; then
+        report_type="${BASH_REMATCH[1]}"
+    fi
+
+    fields="$(parse_report_fields "$file")"
+    IFS=$'\t' read -r track_id generated_at crit high med low info <<<"$fields" || true
+    [[ "$track_id" == "null" ]] && track_id=""
+
+    rel="${file#"$ROOT/"}"
+
+    if $first; then first=false; else printf ','; fi
+    printf '\n {"path":"%s","report_type":"%s","track_id":%s,"generated_at":"%s","severity":{"critical":%s,"high":%s,"medium":%s,"low":%s,"info":%s}}' \
+        "$(json_escape "$rel")" \
+        "$(json_escape "$report_type")" \
+        "$([[ -n "$track_id" ]] && echo "\"$(json_escape "$track_id")\"" || echo "null")" \
+        "$(json_escape "$generated_at")" \
+        "${crit:-0}" "${high:-0}" "${med:-0}" "${low:-0}" "${info:-0}"
+done < <(find "$ROOT" -type f -name '*-report-*.md' -print0 2>/dev/null | sort -z)
+
+if $first; then
+    printf ']\n'
+else
+    printf '\n]\n'
+fi