@drafthq/draft 3.0.0 → 3.2.0

package/scripts/tools/graph-errors.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+# graph-errors.sh — error-propagation paths from the knowledge graph (RAISES/THROWS).
+#
+# graph-tooling-v2 Phase 3. Two modes:
+#   --symbol NAME  what error types NAME raises/throws.
+#   --type NAME    who raises/throws error type NAME (fail-closed audits: confirm
+#                  every site that can emit a given error).
+#
+# Usage:
+#   scripts/tools/graph-errors.sh --repo DIR (--symbol NAME | --type NAME)
+#
+# Output (--symbol): {symbol, raises:[{error,qualified}], status, source}
+# Output (--type):   {type, raisers:[{symbol,file}], status, source}
+#
+# Exit codes: 0 OK, 1 invocation error, 2 graph engine unavailable.
+set -euo pipefail
+
+# shellcheck source=_graph_queries.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_graph_queries.sh"
+
+REPO="."
+SYMBOL=""
+TYPE=""
+
+usage() {
+    cat <<'EOF'
+graph-errors.sh — error propagation (RAISES/THROWS edges).
+
+Usage:
+  scripts/tools/graph-errors.sh --repo DIR (--symbol NAME | --type NAME)
+
+Flags:
+  --repo DIR     Repository root (default: cwd).
+  --symbol NAME  Error types raised/thrown by NAME.
+  --type NAME    Symbols that raise/throw error type NAME.
+  --help         Show this help.
+
+Output: --symbol → {symbol, raises, status, source}; --type → {type, raisers,
+status, source}. Exit 2 when engine unavailable.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --symbol) SYMBOL="$2"; shift 2;;
+        --type) TYPE="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+[[ -d "$REPO" ]] || { echo "ERROR: --repo '$REPO' is not a directory" >&2; exit 1; }
+if [[ -n "$SYMBOL" && -n "$TYPE" ]]; then
+    echo "ERROR: use either --symbol or --type, not both" >&2; exit 1
+fi
+[[ -n "$SYMBOL" || -n "$TYPE" ]] || { echo "ERROR: provide --symbol or --type" >&2; usage >&2; exit 1; }
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+unavailable() {
+    if [[ -n "$TYPE" ]]; then
+        jq -n --arg t "$TYPE" '{type:$t, raisers:[], status:"unavailable", source:"unavailable"}' 2>/dev/null \
+            || echo '{"raisers":[],"status":"unavailable","source":"unavailable"}'
+    else
+        jq -n --arg s "$SYMBOL" '{symbol:$s, raises:[], status:"unavailable", source:"unavailable"}' 2>/dev/null \
+            || echo '{"raises":[],"status":"unavailable","source":"unavailable"}'
+    fi
+    exit 2
+}
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || unavailable
+command -v jq >/dev/null 2>&1 || unavailable
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || unavailable
+
+if [[ -n "$TYPE" ]]; then
+    SYM_ESC="$(gq_escape "$TYPE")"
+    RES="$(gq_run "$PROJECT" "$(gq_q_raisers "$SYM_ESC")" || true)"
+    [[ -n "$RES" ]] || unavailable
+    STATUS="$(gq_symbol_status "$PROJECT" "$SYM_ESC" "$RES")"
+    echo "$RES" | jq --arg t "$TYPE" --arg st "$STATUS" '
+        {type:$t,
+         raisers: [ (.rows // [])[] | {symbol:.[0], file:.[1]} ],
+         status:$st, source:"memory-graph"}'
+else
+    SYM_ESC="$(gq_escape "$SYMBOL")"
+    RES="$(gq_run "$PROJECT" "$(gq_q_raises "$SYM_ESC")" || true)"
+    [[ -n "$RES" ]] || unavailable
+    STATUS="$(gq_symbol_status "$PROJECT" "$SYM_ESC" "$RES")"
+    echo "$RES" | jq --arg s "$SYMBOL" --arg st "$STATUS" '
+        {symbol:$s,
+         raises: [ (.rows // [])[] | {error:.[0], qualified:.[1]} ],
+         status:$st, source:"memory-graph"}'
+fi

package/scripts/tools/graph-hierarchy.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+# graph-hierarchy.sh — class inheritance from the knowledge graph (INHERITS edges).
+#
+# graph-tooling-v2 Phase 3. Answers base/derived relationships and the impact of a
+# base-class change.
+#   (default)        all INHERITS edges (child → parent).
+#   --symbol NAME    bases of class NAME (what NAME inherits from).
+#   --derived NAME   subclasses of class NAME (who inherits from NAME — the blast
+#                    radius of changing NAME).
+#
+# Usage:
+#   scripts/tools/graph-hierarchy.sh --repo DIR [--symbol NAME | --derived NAME]
+#
+# Output: JSON {edges:[{child,parent}], status, source}.
+#
+# Exit codes: 0 OK, 1 invocation error, 2 graph engine unavailable.
+set -euo pipefail
+
+# shellcheck source=_graph_queries.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_graph_queries.sh"
+
+REPO="."
+SYMBOL=""
+DERIVED=""
+
+usage() {
+    cat <<'EOF'
+graph-hierarchy.sh — class inheritance (INHERITS edges).
+
+Usage:
+  scripts/tools/graph-hierarchy.sh --repo DIR [--symbol NAME | --derived NAME]
+
+Flags:
+  --repo DIR      Repository root (default: cwd).
+  --symbol NAME   Bases of class NAME (what it inherits from).
+  --derived NAME  Subclasses of class NAME (impact of changing NAME).
+  --help          Show this help.
+
+Output: JSON {edges:[{child,parent}], status, source}. With no class filter,
+emits the full hierarchy. Exit 2 when engine unavailable.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --symbol) SYMBOL="$2"; shift 2;;
+        --derived) DERIVED="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+[[ -d "$REPO" ]] || { echo "ERROR: --repo '$REPO' is not a directory" >&2; exit 1; }
+if [[ -n "$SYMBOL" && -n "$DERIVED" ]]; then
+    echo "ERROR: use either --symbol or --derived, not both" >&2; exit 1
+fi
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+unavailable() { echo '{"edges":[],"status":"unavailable","source":"unavailable"}'; exit 2; }
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || unavailable
+command -v jq >/dev/null 2>&1 || unavailable
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || unavailable
+
+if [[ -n "$SYMBOL" ]]; then
+    SYM_ESC="$(gq_escape "$SYMBOL")"; Q="$(gq_q_inherits_sym "$SYM_ESC")"; PROBE="$SYM_ESC"
+elif [[ -n "$DERIVED" ]]; then
+    SYM_ESC="$(gq_escape "$DERIVED")"; Q="$(gq_q_derived_sym "$SYM_ESC")"; PROBE="$SYM_ESC"
+else
+    Q="$(gq_q_inherits)"; PROBE=""
+fi
+
+RES="$(gq_run "$PROJECT" "$Q" || true)"
+[[ -n "$RES" ]] || unavailable
+
+if [[ -n "$PROBE" ]]; then
+    STATUS="$(gq_symbol_status "$PROJECT" "$PROBE" "$RES")"
+else
+    STATUS="ok"
+fi
+
+echo "$RES" | jq --arg st "$STATUS" '
+    {edges: [ (.rows // [])[] | {child:.[0], parent:.[1]} ],
+     status:$st, source:"memory-graph"}'

package/scripts/tools/graph-impact.sh

@@ -54,6 +54,7 @@ done
 
 [[ -d "$REPO" ]] || { echo "ERROR: --repo '$REPO' is not a directory" >&2; exit 1; }
 [[ -n "$FILE" || -n "$SYMBOL" ]] || { echo "ERROR: provide --file or --symbol" >&2; usage >&2; exit 1; }
+[[ "$DEPTH" =~ ^[0-9]+$ ]] || { echo "ERROR: --depth must be a non-negative integer" >&2; exit 1; }
 
 REPO_ABS="$(cd "$REPO" && pwd)"
 SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"

package/scripts/tools/graph-init.sh

@@ -104,8 +104,8 @@ engine_unavailable() {
     exit 2
 }
 
-# Build a committed snapshot for a repo dir; returns graph-snapshot's exit code.
-# Snapshot progress goes to stderr so stdout stays clean for --json consumers.
+# Index a repo dir and write its schema.yaml gate marker; returns graph-snapshot's exit code.
+# Progress goes to stderr so stdout stays clean for --json consumers.
 build_snapshot() {
     local rc=0
     "$TOOLS_DIR/graph-snapshot.sh" --repo "$1" 1>&2 || rc=$?
@@ -134,7 +134,7 @@ write_root_link() {
         [[ -n "$root_project" ]] || root_project="unknown"
     fi
     root_commit="$(git -C "$ROOT_ABS" rev-parse --verify --quiet HEAD 2>/dev/null || echo none)"
-    ts="$(date -Iseconds 2>/dev/null || date)"
+    ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
     cat > "$mod_graph/root-link.json" <<EOF
 {
   "root_graph": "$rel",

package/scripts/tools/graph-query.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# graph-query.sh — generic read-only escape hatch to the knowledge-graph engine.
+#
+# The highest-leverage single addition (graph-tooling-v2 Phase 2): unlocks all 20
+# edge types and ~30 pre-computed node properties with no new wrapper. Two modes:
+#
+#   --cypher 'MATCH ...'         run arbitrary read-only openCypher (write verbs
+#                                are rejected before the engine ever sees them).
+#   --tool NAME --json '{...}'   passthrough to any read-only engine tool
+#                                (get_code_snippet, search_graph, get_graph_schema,
+#                                trace_path, …). Destructive tools are rejected.
+#
+# Dialect limits (engine v0.8.x — see _graph_queries.sh for the full list):
+#   SAFE   : fixed-length patterns, `=`, `<`, `STARTS WITH`, `NOT x STARTS WITH`,
+#            `AND`, `OR`, rel-type alternation `[:A|B]`, `count(x)`.
+#   UNSAFE : coalesce(), `<>`/`!=`/`<=`/`>=`, NOT EXISTS(...), NOT (pattern),
+#            WITH-grouping aggregation, multi-pattern joins.
+# Passthrough returns the engine's raw error, not a silent empty result.
+#
+# Usage:
+#   scripts/tools/graph-query.sh --repo DIR --cypher 'MATCH (n) RETURN n LIMIT 5'
+#   scripts/tools/graph-query.sh --repo DIR --tool get_graph_schema --json '{}'
+#
+# Output: the raw engine JSON on success; {"source":"unavailable"} (exit 2) when
+# the engine is unavailable. Exit 1 on invocation error / rejected write.
+set -euo pipefail
+
+# shellcheck source=_graph_queries.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_graph_queries.sh"
+
+REPO="."
+CYPHER=""
+TOOL=""
+TOOL_JSON="{}"
+
+usage() {
+    cat <<'EOF'
+graph-query.sh — generic read-only passthrough to the knowledge-graph engine.
+
+Usage:
+  scripts/tools/graph-query.sh --repo DIR --cypher 'MATCH ... RETURN ...'
+  scripts/tools/graph-query.sh --repo DIR --tool NAME [--json '{...}']
+
+Flags:
+  --repo DIR     Repository root (default: cwd).
+  --cypher STR   Read-only openCypher query (write verbs CREATE/MERGE/DELETE/SET/
+                 REMOVE/DROP/DETACH are rejected). The {project} is injected.
+  --tool NAME    Engine tool to call (read-only allowlist). Combine with --json.
+  --json STR     JSON args for --tool (the project is injected if absent).
+  --help         Show this help.
+
+Dialect: avoid coalesce(), <>, NOT EXISTS, NOT(pattern), WITH-aggregation,
+multi-pattern joins. Use =, <, STARTS WITH, AND/OR, [:A|B] alternation.
+
+Output: raw engine JSON on success; {"source":"unavailable"} (exit 2) when the
+engine is unavailable; exit 1 on invocation error or a rejected write verb.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --cypher) CYPHER="$2"; shift 2;;
+        --tool) TOOL="$2"; shift 2;;
+        --json) TOOL_JSON="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+[[ -d "$REPO" ]] || { echo "ERROR: --repo '$REPO' is not a directory" >&2; exit 1; }
+if [[ -n "$CYPHER" && -n "$TOOL" ]]; then
+    echo "ERROR: use either --cypher or --tool, not both" >&2; exit 1
+fi
+if [[ -z "$CYPHER" && -z "$TOOL" ]]; then
+    echo "ERROR: provide --cypher or --tool" >&2; usage >&2; exit 1
+fi
+
+# Read-only allowlist for --tool mode. Destructive/mutating tools are not exposed
+# through this generic hatch (delete_project, index_repository, manage_adr,
+# ingest_traces) — use the purpose-built wrappers, which guard them explicitly.
+TOOL_ALLOW=" get_architecture query_graph trace_path detect_changes get_code_snippet search_graph search_code get_graph_schema index_status list_projects "
+
+if [[ -n "$TOOL" ]]; then
+    [[ "$TOOL_ALLOW" == *" $TOOL "* ]] || {
+        echo "ERROR: tool '$TOOL' is not in the read-only allowlist" >&2
+        echo "Allowed:$TOOL_ALLOW" >&2
+        exit 1
+    }
+fi
+
+# Reject write verbs in --cypher BEFORE the engine sees the query.
+if [[ -n "$CYPHER" ]]; then
+    UPPER="$(printf '%s' "$CYPHER" | tr '[:lower:]' '[:upper:]')"
+    if printf '%s' "$UPPER" | grep -Eqw 'CREATE|MERGE|DELETE|SET|REMOVE|DROP|DETACH'; then
+        echo "ERROR: write verbs are not allowed (read-only passthrough)" >&2
+        exit 1
+    fi
+fi
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+unavailable() { echo '{"source":"unavailable"}'; exit 2; }
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || unavailable
+command -v jq >/dev/null 2>&1 || unavailable
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || unavailable
+
+if [[ -n "$CYPHER" ]]; then
+    RES="$(gq_run "$PROJECT" "$CYPHER" || true)"
+    [[ -n "$RES" ]] || unavailable
+    printf '%s\n' "$RES"
+else
+    # Inject the resolved project into the tool args unless the caller set one.
+    echo "$TOOL_JSON" | jq -e . >/dev/null 2>&1 || { echo "ERROR: --json is not valid JSON" >&2; exit 1; }
+    ARGS="$(echo "$TOOL_JSON" | jq -c --arg p "$PROJECT" 'if has("project") then . else . + {project:$p} end')"
+    RES="$(memory_cli "$TOOL" "$ARGS" 2>/dev/null || true)"
+    [[ -n "$RES" ]] || unavailable
+    echo "$RES" | jq -e . >/dev/null 2>&1 || unavailable
+    printf '%s\n' "$RES"
+fi

package/scripts/tools/graph-risk.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# graph-risk.sh — pre-computed risk hotspots from the knowledge graph node props.
+#
+# graph-tooling-v2 Phase 3. The engine already computes per-symbol risk flags
+# (unguarded_recursion, recursion_in_loop, alloc_in_loop, linear_scan_in_loop)
+# during indexing. This wrapper surfaces them so bughunt / deep-review consume the
+# engine's findings instead of re-deriving them by hand.
+#
+# Usage:
+#   scripts/tools/graph-risk.sh --repo DIR [--min-complexity N]
+#
+# Output: JSON {risky:[{symbol, file, complexity, flags:[...]}], total,
+#               truncated, source}. --min-complexity keeps only flagged symbols
+#               whose complexity >= N (filtered client-side; the engine dialect
+#               has no >= operator).
+#
+# Exit codes: 0 OK, 1 invocation error, 2 graph engine unavailable.
+set -euo pipefail
+
+# shellcheck source=_graph_queries.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_graph_queries.sh"
+
+REPO="."
+MIN_COMPLEXITY=0
+
+usage() {
+    cat <<'EOF'
+graph-risk.sh — pre-computed risk hotspots (recursion / in-loop allocations).
+
+Usage:
+  scripts/tools/graph-risk.sh --repo DIR [--min-complexity N]
+
+Flags:
+  --repo DIR           Repository root (default: cwd).
+  --min-complexity N   Keep only flagged symbols with complexity >= N (default 0).
+  --help               Show this help.
+
+Output: JSON {risky:[{symbol, file, complexity, flags}], total, truncated,
+source}. Exit 2 when engine unavailable.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --min-complexity) MIN_COMPLEXITY="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+[[ -d "$REPO" ]] || { echo "ERROR: --repo '$REPO' is not a directory" >&2; exit 1; }
+[[ "$MIN_COMPLEXITY" =~ ^[0-9]+$ ]] || { echo "ERROR: --min-complexity must be a non-negative integer" >&2; exit 1; }
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+unavailable() { echo '{"risky":[],"total":0,"source":"unavailable"}'; exit 2; }
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || unavailable
+command -v jq >/dev/null 2>&1 || unavailable
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || unavailable
+
+RES="$(gq_run "$PROJECT" "$(gq_q_risk)" || true)"
+[[ -n "$RES" ]] || unavailable
+
+# Columns: symbol, file, complexity, unguarded_recursion, alloc_in_loop,
+# recursion_in_loop, linear_scan_in_loop. complexity arrives as a string.
+echo "$RES" | jq --argjson minc "$MIN_COMPLEXITY" '
+    [ (.rows // [])[]
+      | {symbol:.[0], file:.[1], complexity:((.[2] // "0") | tonumber? // 0),
+         flags: ( [ (if (.[3]|tostring) == "true" then "unguarded_recursion" else empty end),
+                    (if (.[4]|tostring) == "true" then "alloc_in_loop" else empty end),
+                    (if (.[5]|tostring) == "true" then "recursion_in_loop" else empty end),
+                    (if (.[6]|tostring) == "true" then "linear_scan_in_loop" else empty end) ] )}
+      | select(.complexity >= $minc) ] as $r
+    | {risky: $r, total: ($r | length),
+       truncated: (((.rows // []) | length) >= 200),
+       source:"memory-graph"}'

package/scripts/tools/graph-search.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# graph-search.sh — semantic / ranked symbol search over the knowledge graph.
+#
+# Wraps the engine's search_graph (graph-tooling-v2 Phase 3): "find code about X"
+# returns vector/text-ranked symbols, not a literal grep. Use when the user names
+# an intent or concept rather than an exact symbol.
+#
+# Usage:
+#   scripts/tools/graph-search.sh --repo DIR --query "order submission to broker" [--limit N]
+#
+# Output: JSON {query, results:[{name, qualified_name, label, file, start_line,
+#               end_line, rank}], total, source}.
+#
+# Exit codes: 0 OK, 1 invocation error, 2 graph engine unavailable.
+set -euo pipefail
+
+# shellcheck source=_graph_queries.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_graph_queries.sh"
+
+REPO="."
+QUERY=""
+LIMIT=10
+
+usage() {
+    cat <<'EOF'
+graph-search.sh — semantic / ranked symbol search.
+
+Usage:
+  scripts/tools/graph-search.sh --repo DIR --query "STR" [--limit N]
+
+Flags:
+  --repo DIR   Repository root (default: cwd).
+  --query STR  Natural-language or keyword query (required).
+  --limit N    Max results (default: 10).
+  --help       Show this help.
+
+Output: JSON {query, results, total, source}. Exit 2 when engine unavailable.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --query) QUERY="$2"; shift 2;;
+        --limit) LIMIT="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+[[ -d "$REPO" ]] || { echo "ERROR: --repo '$REPO' is not a directory" >&2; exit 1; }
+[[ -n "$QUERY" ]] || { echo "ERROR: --query is required" >&2; usage >&2; exit 1; }
+[[ "$LIMIT" =~ ^[0-9]+$ ]] || { echo "ERROR: --limit must be a non-negative integer" >&2; exit 1; }
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+unavailable() {
+    jq -n --arg q "$QUERY" '{query:$q, results:[], source:"unavailable"}' 2>/dev/null \
+        || echo '{"results":[],"source":"unavailable"}'
+    exit 2
+}
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || unavailable
+command -v jq >/dev/null 2>&1 || unavailable
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || unavailable
+
+ARGS="$(jq -n --arg p "$PROJECT" --arg q "$QUERY" --argjson n "$LIMIT" \
+    '{project:$p, query:$q, limit:$n}')"
+RES="$(memory_cli search_graph "$ARGS" 2>/dev/null || true)"
+[[ -n "$RES" ]] || unavailable
+echo "$RES" | jq -e . >/dev/null 2>&1 || unavailable
+
+echo "$RES" | jq --arg q "$QUERY" '
+    {query:$q,
+     results: [ (.results // .matches // [])[]
+                | {name:(.name // ""), qualified_name:(.qualified_name // ""),
+                   label:(.label // ""), file:(.file_path // .file // ""),
+                   start_line:(.start_line // null), end_line:(.end_line // null),
+                   rank:(.rank // .score // null)} ],
+     total: ((.results // .matches // []) | length),
+     source:"memory-graph"}'