gsd-pi 2.41.0 → 2.42.0-dev.eedc83f

package/dist/resources/extensions/gsd/rule-registry.js

@@ -0,0 +1,489 @@
+// GSD Extension — Unified Rule Registry
+//
+// Holds all dispatch rules and hooks as a flat list of UnifiedRule objects.
+// Provides evaluation methods for each phase (dispatch, post-unit, pre-dispatch)
+// and encapsulates mutable hook state as instance fields.
+//
+// A module-level singleton accessor allows existing code to migrate incrementally.
+import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+// ─── Artifact Path Resolution ──────────────────────────────────────────────
+export function resolveHookArtifactPath(basePath, unitId, artifactName) {
+    const parts = unitId.split("/");
+    if (parts.length === 3) {
+        const [mid, sid, tid] = parts;
+        return join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks", `${tid}-${artifactName}`);
+    }
+    if (parts.length === 2) {
+        const [mid, sid] = parts;
+        return join(basePath, ".gsd", "milestones", mid, "slices", sid, artifactName);
+    }
+    return join(basePath, ".gsd", "milestones", parts[0], artifactName);
+}
+// ─── Dispatch Rule Conversion ──────────────────────────────────────────────
+/**
+ * Convert an array of DispatchRule objects to UnifiedRule[] format.
+ * Preserves exact array order — dispatch is order-dependent (first-match-wins).
+ */
+export function convertDispatchRules(rules) {
+    return rules.map((rule) => ({
+        name: rule.name,
+        when: "dispatch",
+        evaluation: "first-match",
+        where: rule.match,
+        then: (result) => result,
+        description: `Dispatch rule: ${rule.name}`,
+    }));
+}
+// ─── RuleRegistry ─────────────────────────────────────────────────────────
+const HOOK_STATE_FILE = "hook-state.json";
+export class RuleRegistry {
+    /** Static dispatch rules provided at construction time. */
+    dispatchRules;
+    // ── Mutable hook state (encapsulated, not module-level) ──────────────
+    activeHook = null;
+    hookQueue = [];
+    cycleCounts = new Map();
+    retryPending = false;
+    retryTrigger = null;
+    constructor(dispatchRules) {
+        this.dispatchRules = dispatchRules;
+    }
+    // ── Core query ───────────────────────────────────────────────────────
+    /**
+     * Returns all rules: static dispatch rules + dynamically loaded hook rules.
+     * Hook rules are loaded fresh from preferences on each call (not cached).
+     */
+    listRules() {
+        const rules = [...this.dispatchRules];
+        // Convert post-unit hooks to unified rules
+        const postHooks = resolvePostUnitHooks();
+        for (const hook of postHooks) {
+            rules.push({
+                name: hook.name,
+                when: "post-unit",
+                evaluation: "all-matching",
+                where: (unitType) => hook.after.includes(unitType),
+                then: () => hook,
+                description: `Post-unit hook: fires after ${hook.after.join(", ")}`,
+                lifecycle: {
+                    artifact: hook.artifact,
+                    retry_on: hook.retry_on,
+                    max_cycles: hook.max_cycles,
+                },
+            });
+        }
+        // Convert pre-dispatch hooks to unified rules
+        const preHooks = resolvePreDispatchHooks();
+        for (const hook of preHooks) {
+            rules.push({
+                name: hook.name,
+                when: "pre-dispatch",
+                evaluation: "all-matching",
+                where: (unitType) => hook.before.includes(unitType),
+                then: () => hook,
+                description: `Pre-dispatch hook: fires before ${hook.before.join(", ")}`,
+            });
+        }
+        return rules;
+    }
+    // ── Dispatch evaluation (async, first-match-wins) ───────────────────
+    /**
+     * Iterate dispatch rules in order. First match wins.
+     * Returns stop action if no rule matches (unhandled phase).
+     */
+    async evaluateDispatch(ctx) {
+        for (const rule of this.dispatchRules) {
+            const result = await rule.where(ctx);
+            if (result) {
+                if (result.action !== "skip")
+                    result.matchedRule = rule.name;
+                return result;
+            }
+        }
+        return {
+            action: "stop",
+            reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
+            level: "info",
+            matchedRule: "<no-match>",
+        };
+    }
+    // ── Post-unit hook evaluation (sync, all-matching with lifecycle) ────
+    /**
+     * Replicate exact semantics of checkPostUnitHooks from post-unit-hooks.ts:
+     * hook-on-hook prevention, idempotency, cycle limits, retry_on, dequeue.
+     */
+    evaluatePostUnit(completedUnitType, completedUnitId, basePath) {
+        // If we just completed a hook unit, handle its result
+        if (this.activeHook) {
+            return this._handleHookCompletion(basePath);
+        }
+        // Don't trigger hooks for other hook units (prevent hook-on-hook chains)
+        // Don't trigger hooks for triage units or quick-task units
+        if (completedUnitType.startsWith("hook/") ||
+            completedUnitType === "triage-captures" ||
+            completedUnitType === "quick-task") {
+            return null;
+        }
+        // Check if any hooks are configured for this unit type
+        const hooks = resolvePostUnitHooks().filter(h => h.after.includes(completedUnitType));
+        if (hooks.length === 0)
+            return null;
+        // Build hook queue for this trigger
+        this.hookQueue = hooks.map(config => ({
+            config,
+            triggerUnitType: completedUnitType,
+            triggerUnitId: completedUnitId,
+        }));
+        return this._dequeueNextHook(basePath);
+    }
+    _dequeueNextHook(basePath) {
+        while (this.hookQueue.length > 0) {
+            const entry = this.hookQueue.shift();
+            const { config, triggerUnitType, triggerUnitId } = entry;
+            // Check idempotency — if artifact already exists, skip
+            if (config.artifact) {
+                const artifactPath = resolveHookArtifactPath(basePath, triggerUnitId, config.artifact);
+                if (existsSync(artifactPath))
+                    continue;
+            }
+            // Check cycle limit
+            const cycleKey = `${config.name}/${triggerUnitType}/${triggerUnitId}`;
+            const currentCycle = (this.cycleCounts.get(cycleKey) ?? 0) + 1;
+            const maxCycles = config.max_cycles ?? 1;
+            if (currentCycle > maxCycles)
+                continue;
+            this.cycleCounts.set(cycleKey, currentCycle);
+            this.activeHook = {
+                hookName: config.name,
+                triggerUnitType,
+                triggerUnitId,
+                cycle: currentCycle,
+                pendingRetry: false,
+            };
+            // Build prompt with variable substitution
+            const [mid, sid, tid] = triggerUnitId.split("/");
+            let prompt = config.prompt
+                .replace(/\{milestoneId\}/g, mid ?? "")
+                .replace(/\{sliceId\}/g, sid ?? "")
+                .replace(/\{taskId\}/g, tid ?? "");
+            // Inject browser safety instruction
+            prompt += "\n\n**Browser tool safety:** Do NOT use `browser_wait_for` with `condition: \"network_idle\"` — it hangs indefinitely when dev servers keep persistent connections (Vite HMR, WebSocket). Use `selector_visible`, `text_visible`, or `delay` instead.";
+            return {
+                hookName: config.name,
+                prompt,
+                model: config.model,
+                unitType: `hook/${config.name}`,
+                unitId: triggerUnitId,
+            };
+        }
+        // No more hooks — clear active state
+        this.activeHook = null;
+        return null;
+    }
+    _handleHookCompletion(basePath) {
+        const hook = this.activeHook;
+        const hooks = resolvePostUnitHooks();
+        const config = hooks.find(h => h.name === hook.hookName);
+        // Check if retry was requested via retry_on artifact
+        if (config?.retry_on) {
+            const retryArtifactPath = resolveHookArtifactPath(basePath, hook.triggerUnitId, config.retry_on);
+            if (existsSync(retryArtifactPath)) {
+                const cycleKey = `${config.name}/${hook.triggerUnitType}/${hook.triggerUnitId}`;
+                const currentCycle = this.cycleCounts.get(cycleKey) ?? 1;
+                const maxCycles = config.max_cycles ?? 1;
+                if (currentCycle < maxCycles) {
+                    this.activeHook = null;
+                    this.hookQueue = [];
+                    this.retryPending = true;
+                    this.retryTrigger = {
+                        unitType: hook.triggerUnitType,
+                        unitId: hook.triggerUnitId,
+                        retryArtifact: config.retry_on,
+                    };
+                    return null;
+                }
+            }
+        }
+        // Hook completed normally — try next hook in queue
+        this.activeHook = null;
+        return this._dequeueNextHook(basePath);
+    }
+    // ── Pre-dispatch hook evaluation (sync, all-matching with compose) ──
+    /**
+     * Replicate exact semantics of runPreDispatchHooks from post-unit-hooks.ts:
+     * modify/skip/replace compose semantics.
+     */
+    evaluatePreDispatch(unitType, unitId, prompt, basePath) {
+        // Don't intercept hook units
+        if (unitType.startsWith("hook/")) {
+            return { action: "proceed", prompt, firedHooks: [] };
+        }
+        const hooks = resolvePreDispatchHooks().filter(h => h.before.includes(unitType));
+        if (hooks.length === 0) {
+            return { action: "proceed", prompt, firedHooks: [] };
+        }
+        const [mid, sid, tid] = unitId.split("/");
+        const substitute = (text) => text
+            .replace(/\{milestoneId\}/g, mid ?? "")
+            .replace(/\{sliceId\}/g, sid ?? "")
+            .replace(/\{taskId\}/g, tid ?? "");
+        const firedHooks = [];
+        let currentPrompt = prompt;
+        for (const hook of hooks) {
+            if (hook.action === "skip") {
+                if (hook.skip_if) {
+                    const conditionPath = resolveHookArtifactPath(basePath, unitId, hook.skip_if);
+                    if (!existsSync(conditionPath))
+                        continue;
+                }
+                firedHooks.push(hook.name);
+                return { action: "skip", firedHooks };
+            }
+            if (hook.action === "replace") {
+                firedHooks.push(hook.name);
+                return {
+                    action: "replace",
+                    prompt: substitute(hook.prompt ?? ""),
+                    unitType: hook.unit_type,
+                    model: hook.model,
+                    firedHooks,
+                };
+            }
+            if (hook.action === "modify") {
+                firedHooks.push(hook.name);
+                if (hook.prepend) {
+                    currentPrompt = `${substitute(hook.prepend)}\n\n${currentPrompt}`;
+                }
+                if (hook.append) {
+                    currentPrompt = `${currentPrompt}\n\n${substitute(hook.append)}`;
+                }
+            }
+        }
+        return {
+            action: "proceed",
+            prompt: currentPrompt,
+            model: hooks.find(h => h.action === "modify" && h.model)?.model,
+            firedHooks,
+        };
+    }
+    // ── State accessors ─────────────────────────────────────────────────
+    getActiveHook() {
+        return this.activeHook;
+    }
+    isRetryPending() {
+        return this.retryPending;
+    }
+    /**
+     * Returns the trigger unit info for a pending retry, or null.
+     * Clears the retry state after reading.
+     */
+    consumeRetryTrigger() {
+        if (!this.retryPending || !this.retryTrigger)
+            return null;
+        const trigger = { ...this.retryTrigger };
+        this.retryPending = false;
+        this.retryTrigger = null;
+        return trigger;
+    }
+    /** Clear all mutable state (activeHook, hookQueue, cycleCounts, retryPending, retryTrigger). */
+    resetState() {
+        this.activeHook = null;
+        this.hookQueue = [];
+        this.cycleCounts.clear();
+        this.retryPending = false;
+        this.retryTrigger = null;
+    }
+    // ── Persistence ─────────────────────────────────────────────────────
+    _hookStatePath(basePath) {
+        return join(basePath, ".gsd", HOOK_STATE_FILE);
+    }
+    /** Persist current hook cycle counts to disk. */
+    persistState(basePath) {
+        const state = {
+            cycleCounts: Object.fromEntries(this.cycleCounts),
+            savedAt: new Date().toISOString(),
+        };
+        try {
+            const dir = join(basePath, ".gsd");
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(this._hookStatePath(basePath), JSON.stringify(state, null, 2), "utf-8");
+        }
+        catch {
+            // Non-fatal — state is recreatable from artifacts
+        }
+    }
+    /** Restore hook cycle counts from disk after a crash/restart. */
+    restoreState(basePath) {
+        try {
+            const filePath = this._hookStatePath(basePath);
+            if (!existsSync(filePath))
+                return;
+            const raw = readFileSync(filePath, "utf-8");
+            const state = JSON.parse(raw);
+            if (state.cycleCounts && typeof state.cycleCounts === "object") {
+                this.cycleCounts.clear();
+                for (const [key, value] of Object.entries(state.cycleCounts)) {
+                    if (typeof value === "number") {
+                        this.cycleCounts.set(key, value);
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-fatal — fresh state is fine
+        }
+    }
+    /** Clear persisted hook state file from disk. */
+    clearPersistedState(basePath) {
+        try {
+            const filePath = this._hookStatePath(basePath);
+            if (existsSync(filePath)) {
+                writeFileSync(filePath, JSON.stringify({ cycleCounts: {}, savedAt: new Date().toISOString() }, null, 2), "utf-8");
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    // ── Hook status reporting ───────────────────────────────────────────
+    /** Get status of all configured hooks for display. */
+    getHookStatus() {
+        const entries = [];
+        const postHooks = resolvePostUnitHooks();
+        for (const hook of postHooks) {
+            const activeCycles = {};
+            for (const [key, count] of this.cycleCounts) {
+                if (key.startsWith(`${hook.name}/`)) {
+                    activeCycles[key] = count;
+                }
+            }
+            entries.push({
+                name: hook.name,
+                type: "post",
+                enabled: hook.enabled !== false,
+                targets: hook.after,
+                activeCycles,
+            });
+        }
+        const preHooks = resolvePreDispatchHooks();
+        for (const hook of preHooks) {
+            entries.push({
+                name: hook.name,
+                type: "pre",
+                enabled: hook.enabled !== false,
+                targets: hook.before,
+                activeCycles: {},
+            });
+        }
+        return entries;
+    }
+    /**
+     * Manually trigger a specific hook for a unit.
+     * Bypasses normal flow — forces hook to run even if artifact exists.
+     */
+    triggerHookManually(hookName, unitType, unitId, basePath) {
+        const hook = resolvePostUnitHooks().find(h => h.name === hookName);
+        if (!hook) {
+            console.error(`[triggerHookManually] Hook "${hookName}" not found in post_unit_hooks`);
+            return null;
+        }
+        if (!hook.prompt || typeof hook.prompt !== "string" || hook.prompt.trim().length === 0) {
+            console.error(`[triggerHookManually] Hook "${hookName}" has empty prompt`);
+            return null;
+        }
+        this.activeHook = {
+            hookName: hook.name,
+            triggerUnitType: unitType,
+            triggerUnitId: unitId,
+            cycle: 1,
+            pendingRetry: false,
+        };
+        this.hookQueue = [{
+                config: hook,
+                triggerUnitType: unitType,
+                triggerUnitId: unitId,
+            }];
+        const cycleKey = `${hook.name}/${unitType}/${unitId}`;
+        const currentCycle = (this.cycleCounts.get(cycleKey) ?? 0) + 1;
+        this.cycleCounts.set(cycleKey, currentCycle);
+        this.activeHook.cycle = currentCycle;
+        const [mid, sid, tid] = unitId.split("/");
+        const prompt = hook.prompt
+            .replace(/\{milestoneId\}/g, mid ?? "")
+            .replace(/\{sliceId\}/g, sid ?? "")
+            .replace(/\{taskId\}/g, tid ?? "");
+        return {
+            hookName: hook.name,
+            prompt,
+            model: hook.model,
+            unitType: `hook/${hook.name}`,
+            unitId,
+        };
+    }
+    /** Format hook status for terminal display. */
+    formatHookStatus() {
+        const entries = this.getHookStatus();
+        if (entries.length === 0) {
+            return "No hooks configured. Add post_unit_hooks or pre_dispatch_hooks to .gsd/preferences.md";
+        }
+        const lines = ["Configured Hooks:", ""];
+        const postHooks = entries.filter(e => e.type === "post");
+        const preHooks = entries.filter(e => e.type === "pre");
+        if (postHooks.length > 0) {
+            lines.push("Post-Unit Hooks (run after unit completes):");
+            for (const hook of postHooks) {
+                const status = hook.enabled ? "enabled" : "disabled";
+                const cycles = Object.keys(hook.activeCycles).length;
+                const cycleInfo = cycles > 0 ? ` (${cycles} active cycle${cycles === 1 ? "" : "s"})` : "";
+                lines.push(`  ${hook.name} [${status}] → after: ${hook.targets.join(", ")}${cycleInfo}`);
+            }
+            lines.push("");
+        }
+        if (preHooks.length > 0) {
+            lines.push("Pre-Dispatch Hooks (run before unit dispatches):");
+            for (const hook of preHooks) {
+                const status = hook.enabled ? "enabled" : "disabled";
+                lines.push(`  ${hook.name} [${status}] → before: ${hook.targets.join(", ")}`);
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    }
+}
+// ─── Module-level Singleton ─────────────────────────────────────────────────
+let _registry = null;
+/** Get the singleton registry. Throws if not initialized. */
+export function getRegistry() {
+    if (!_registry) {
+        throw new Error("RuleRegistry not initialized — call initRegistry() or setRegistry() first.");
+    }
+    return _registry;
+}
+/** Set the singleton registry instance. */
+export function setRegistry(r) {
+    _registry = r;
+}
+/** Create and set the singleton registry with the given dispatch rules. */
+export function initRegistry(dispatchRules) {
+    const registry = new RuleRegistry(dispatchRules);
+    setRegistry(registry);
+    return registry;
+}
+/**
+ * Get the singleton registry, lazily creating one with empty dispatch rules
+ * if not yet initialized. This ensures facade functions work even when
+ * the full registry hasn't been set up (e.g. during testing).
+ */
+export function getOrCreateRegistry() {
+    if (!_registry) {
+        _registry = new RuleRegistry([]);
+    }
+    return _registry;
+}
+/** Reset the singleton (for testing). */
+export function resetRegistry() {
+    _registry = null;
+}

package/dist/resources/extensions/gsd/rule-types.js

@@ -0,0 +1,6 @@
+// GSD Extension — Unified Rule Type Definitions
+//
+// Every dispatch rule and hook is expressed as a `UnifiedRule` with a
+// consistent when/where/then shape. This file defines the type system;
+// the `RuleRegistry` class in rule-registry.ts holds instances at runtime.
+export {};

package/dist/resources/extensions/gsd/run-manager.js

@@ -0,0 +1,134 @@
+/**
+ * run-manager.ts — Create and list isolated workflow run directories.
+ *
+ * Each run lives under `.gsd/workflow-runs/<name>/<timestamp>/` and contains:
+ * - DEFINITION.yaml — frozen snapshot of the workflow definition at run-creation time
+ * - GRAPH.yaml — initialized step graph with all steps pending
+ * - PARAMS.json — (optional) parameter overrides used for this run
+ *
+ * Observability:
+ * - All run state is on disk in human-readable YAML/JSON — inspectable with cat/less.
+ * - `listRuns()` returns structured metadata including step counts and overall status.
+ * - Timestamp directory names are filesystem-safe (ISO with hyphens replacing colons).
+ * - Errors include the full path context for diagnosis.
+ */
+import { mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { stringify } from "yaml";
+import { loadDefinition, substituteParams } from "./definition-loader.js";
+import { initializeGraph, writeGraph, readGraph } from "./graph.js";
+// ─── Constants ───────────────────────────────────────────────────────────
+const RUNS_DIR = "workflow-runs";
+const DEFS_DIR = "workflow-defs";
+// ─── Helpers ─────────────────────────────────────────────────────────────
+/**
+ * Generate a filesystem-safe timestamp: `YYYY-MM-DDTHH-MM-SS`.
+ * Replaces colons with hyphens so the string is safe as a directory name
+ * on all platforms (Windows forbids colons in paths).
+ */
+function makeTimestamp(date = new Date()) {
+    return date.toISOString().replace(/:/g, "-").replace(/\.\d{3}Z$/, "");
+}
+/**
+ * Derive overall status from a graph's step statuses.
+ */
+function deriveStatus(graph) {
+    const hasActive = graph.steps.some((s) => s.status === "active");
+    const allDone = graph.steps.every((s) => s.status === "complete" || s.status === "expanded");
+    if (allDone)
+        return "complete";
+    if (hasActive)
+        return "running";
+    return "pending";
+}
+// ─── Public API ──────────────────────────────────────────────────────────
+/**
+ * Create a new isolated run directory for a workflow definition.
+ *
+ * 1. Loads the definition from `<basePath>/.gsd/workflow-defs/<defName>.yaml`
+ * 2. Applies parameter substitution if overrides are provided
+ * 3. Creates `<basePath>/.gsd/workflow-runs/<defName>/<timestamp>/`
+ * 4. Writes frozen DEFINITION.yaml, initialized GRAPH.yaml, and optional PARAMS.json
+ *
+ * @param basePath — project root directory
+ * @param defName — definition filename (without .yaml extension)
+ * @param overrides — optional parameter overrides (merged with definition defaults)
+ * @returns Full path to the created run directory
+ * @throws Error if the definition file doesn't exist or is invalid
+ */
+export function createRun(basePath, defName, overrides) {
+    const defsDir = join(basePath, ".gsd", DEFS_DIR);
+    // Load and validate the definition
+    const rawDef = loadDefinition(defsDir, defName);
+    // Apply parameter substitution if overrides provided
+    const def = overrides
+        ? substituteParams(rawDef, overrides)
+        : substituteParams(rawDef); // still resolve default params if any
+    // Create the run directory
+    const timestamp = makeTimestamp();
+    const runDir = join(basePath, ".gsd", RUNS_DIR, defName, timestamp);
+    mkdirSync(runDir, { recursive: true });
+    // Freeze the definition as DEFINITION.yaml
+    writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
+    // Initialize and write GRAPH.yaml
+    const graph = initializeGraph(def);
+    writeGraph(runDir, graph);
+    // Write PARAMS.json if overrides were provided
+    if (overrides && Object.keys(overrides).length > 0) {
+        writeFileSync(join(runDir, "PARAMS.json"), JSON.stringify(overrides, null, 2), "utf-8");
+    }
+    return runDir;
+}
+/**
+ * List existing workflow runs with metadata.
+ *
+ * Scans `<basePath>/.gsd/workflow-runs/` for run directories. Each run's
+ * GRAPH.yaml is read to derive step counts and overall status.
+ *
+ * @param basePath — project root directory
+ * @param defName — optional filter: only list runs for this definition name
+ * @returns Array of run metadata, sorted newest-first within each definition
+ */
+export function listRuns(basePath, defName) {
+    const runsRoot = join(basePath, ".gsd", RUNS_DIR);
+    if (!existsSync(runsRoot))
+        return [];
+    const results = [];
+    // Get workflow name directories
+    const nameDirs = defName ? [defName] : readdirSync(runsRoot).filter((entry) => {
+        const full = join(runsRoot, entry);
+        return statSync(full).isDirectory();
+    });
+    for (const name of nameDirs) {
+        const nameDir = join(runsRoot, name);
+        if (!existsSync(nameDir))
+            continue;
+        const timestamps = readdirSync(nameDir).filter((entry) => {
+            const full = join(nameDir, entry);
+            return statSync(full).isDirectory();
+        });
+        // Sort newest-first (ISO strings sort lexicographically)
+        timestamps.sort().reverse();
+        for (const ts of timestamps) {
+            const runDir = join(nameDir, ts);
+            try {
+                const graph = readGraph(runDir);
+                const total = graph.steps.length;
+                const completed = graph.steps.filter((s) => s.status === "complete").length;
+                const pending = graph.steps.filter((s) => s.status === "pending").length;
+                const active = graph.steps.filter((s) => s.status === "active").length;
+                results.push({
+                    name,
+                    timestamp: ts,
+                    runDir,
+                    steps: { total, completed, pending, active },
+                    status: deriveStatus(graph),
+                });
+            }
+            catch {
+                // Skip runs with invalid/missing GRAPH.yaml
+            }
+        }
+    }
+    return results;
+}