@grafema/cli 0.1.1-alpha

package/dist/commands/server.js

@@ -0,0 +1,300 @@
+/**
+ * Server command - Manage RFDB server lifecycle
+ *
+ * Provides explicit control over the RFDB server process:
+ *   grafema server start   - Start detached server
+ *   grafema server stop    - Stop server gracefully
+ *   grafema server status  - Check if server is running
+ */
+import { Command } from 'commander';
+import { resolve, join, dirname } from 'path';
+import { existsSync, unlinkSync, writeFileSync, readFileSync } from 'fs';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { setTimeout as sleep } from 'timers/promises';
+import { RFDBClient } from '@grafema/core';
+import { exitWithError } from '../utils/errorFormatter.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Find RFDB server binary in order of preference:
+ * 1. @grafema/rfdb npm package
+ * 2. rust-engine/target/release (monorepo development)
+ * 3. rust-engine/target/debug
+ */
+function findServerBinary() {
+    // 1. Check @grafema/rfdb npm package
+    try {
+        const rfdbPkg = require.resolve('@grafema/rfdb');
+        const rfdbDir = dirname(rfdbPkg);
+        const platform = process.platform;
+        const arch = process.arch;
+        let platformDir;
+        if (platform === 'darwin') {
+            platformDir = arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+        }
+        else if (platform === 'linux') {
+            platformDir = arch === 'arm64' ? 'linux-arm64' : 'linux-x64';
+        }
+        else {
+            platformDir = `${platform}-${arch}`;
+        }
+        const npmBinary = join(rfdbDir, 'prebuilt', platformDir, 'rfdb-server');
+        if (existsSync(npmBinary)) {
+            return npmBinary;
+        }
+    }
+    catch {
+        // @grafema/rfdb not installed
+    }
+    // 2. Check rust-engine in monorepo
+    // From packages/cli/dist/commands -> project root is 4 levels up
+    const projectRoot = join(__dirname, '../../../..');
+    const releaseBinary = join(projectRoot, 'rust-engine/target/release/rfdb-server');
+    if (existsSync(releaseBinary)) {
+        return releaseBinary;
+    }
+    // 3. Check debug build
+    const debugBinary = join(projectRoot, 'rust-engine/target/debug/rfdb-server');
+    if (existsSync(debugBinary)) {
+        return debugBinary;
+    }
+    return null;
+}
+/**
+ * Check if server is running by attempting to ping it
+ */
+async function isServerRunning(socketPath) {
+    if (!existsSync(socketPath)) {
+        return { running: false };
+    }
+    const client = new RFDBClient(socketPath);
+    // Suppress error events (we handle via try/catch)
+    client.on('error', () => { });
+    try {
+        await client.connect();
+        const version = await client.ping();
+        await client.close();
+        return { running: true, version: version || undefined };
+    }
+    catch {
+        // Socket exists but can't connect - stale socket
+        return { running: false };
+    }
+}
+/**
+ * Get paths for a project
+ */
+function getProjectPaths(projectPath) {
+    const grafemaDir = join(projectPath, '.grafema');
+    const socketPath = join(grafemaDir, 'rfdb.sock');
+    const dbPath = join(grafemaDir, 'graph.rfdb');
+    const pidPath = join(grafemaDir, 'rfdb.pid');
+    return { grafemaDir, socketPath, dbPath, pidPath };
+}
+// Create main server command with subcommands
+export const serverCommand = new Command('server')
+    .description('Manage RFDB server lifecycle');
+// grafema server start
+serverCommand
+    .command('start')
+    .description('Start the RFDB server')
+    .option('-p, --project <path>', 'Project path', '.')
+    .action(async (options) => {
+    const projectPath = resolve(options.project);
+    const { grafemaDir, socketPath, dbPath, pidPath } = getProjectPaths(projectPath);
+    // Check if grafema is initialized
+    if (!existsSync(grafemaDir)) {
+        exitWithError('Grafema not initialized', [
+            'Run: grafema init',
+            'Or: grafema analyze (initializes automatically)'
+        ]);
+    }
+    // Check if server already running
+    const status = await isServerRunning(socketPath);
+    if (status.running) {
+        console.log(`Server already running at ${socketPath}`);
+        if (status.version) {
+            console.log(`  Version: ${status.version}`);
+        }
+        return;
+    }
+    // Remove stale socket if exists
+    if (existsSync(socketPath)) {
+        unlinkSync(socketPath);
+    }
+    // Find server binary
+    const binaryPath = findServerBinary();
+    if (!binaryPath) {
+        exitWithError('RFDB server binary not found', [
+            'Install: npm install @grafema/rfdb',
+            'Or build: cargo build --release --bin rfdb-server'
+        ]);
+    }
+    console.log(`Starting RFDB server...`);
+    console.log(`  Database: ${dbPath}`);
+    console.log(`  Socket: ${socketPath}`);
+    // Start server
+    const serverProcess = spawn(binaryPath, [dbPath, '--socket', socketPath], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true,
+    });
+    // Don't let server process prevent parent from exiting
+    serverProcess.unref();
+    // Write PID file
+    if (serverProcess.pid) {
+        writeFileSync(pidPath, String(serverProcess.pid));
+    }
+    // Wait for socket to appear
+    let attempts = 0;
+    while (!existsSync(socketPath) && attempts < 50) {
+        await sleep(100);
+        attempts++;
+    }
+    if (!existsSync(socketPath)) {
+        exitWithError('Server failed to start', [
+            'Check if database path is valid',
+            'Check server logs for errors'
+        ]);
+    }
+    // Verify server is responsive
+    const verifyStatus = await isServerRunning(socketPath);
+    if (!verifyStatus.running) {
+        exitWithError('Server started but not responding', [
+            'Check server logs for errors'
+        ]);
+    }
+    console.log('');
+    console.log(`Server started successfully`);
+    if (verifyStatus.version) {
+        console.log(`  Version: ${verifyStatus.version}`);
+    }
+    if (serverProcess.pid) {
+        console.log(`  PID: ${serverProcess.pid}`);
+    }
+});
+// grafema server stop
+serverCommand
+    .command('stop')
+    .description('Stop the RFDB server')
+    .option('-p, --project <path>', 'Project path', '.')
+    .action(async (options) => {
+    const projectPath = resolve(options.project);
+    const { socketPath, pidPath } = getProjectPaths(projectPath);
+    // Check if server is running
+    const status = await isServerRunning(socketPath);
+    if (!status.running) {
+        console.log('Server not running');
+        // Clean up stale socket and PID file
+        if (existsSync(socketPath)) {
+            unlinkSync(socketPath);
+        }
+        if (existsSync(pidPath)) {
+            unlinkSync(pidPath);
+        }
+        return;
+    }
+    console.log('Stopping RFDB server...');
+    // Send shutdown command
+    const client = new RFDBClient(socketPath);
+    // Suppress error events (server closes connection on shutdown)
+    client.on('error', () => { });
+    try {
+        await client.connect();
+        await client.shutdown();
+    }
+    catch {
+        // Expected - server closes connection
+    }
+    // Wait for socket to disappear
+    let attempts = 0;
+    while (existsSync(socketPath) && attempts < 30) {
+        await sleep(100);
+        attempts++;
+    }
+    // Clean up PID file
+    if (existsSync(pidPath)) {
+        unlinkSync(pidPath);
+    }
+    console.log('Server stopped');
+});
+// grafema server status
+serverCommand
+    .command('status')
+    .description('Check RFDB server status')
+    .option('-p, --project <path>', 'Project path', '.')
+    .option('-j, --json', 'Output as JSON')
+    .action(async (options) => {
+    const projectPath = resolve(options.project);
+    const { grafemaDir, socketPath, dbPath, pidPath } = getProjectPaths(projectPath);
+    // Check if grafema is initialized
+    const initialized = existsSync(grafemaDir);
+    // Check server status
+    const status = await isServerRunning(socketPath);
+    // Read PID if available
+    let pid = null;
+    if (existsSync(pidPath)) {
+        try {
+            pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    // Get stats if running
+    let nodeCount;
+    let edgeCount;
+    if (status.running) {
+        const client = new RFDBClient(socketPath);
+        client.on('error', () => { }); // Suppress error events
+        try {
+            await client.connect();
+            nodeCount = await client.nodeCount();
+            edgeCount = await client.edgeCount();
+            await client.close();
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            initialized,
+            running: status.running,
+            version: status.version || null,
+            socketPath: initialized ? socketPath : null,
+            dbPath: initialized ? dbPath : null,
+            pid,
+            nodeCount,
+            edgeCount,
+        }, null, 2));
+        return;
+    }
+    // Text output
+    if (!initialized) {
+        console.log('Grafema not initialized');
+        console.log('  Run: grafema init');
+        return;
+    }
+    if (status.running) {
+        console.log('RFDB server is running');
+        console.log(`  Socket: ${socketPath}`);
+        if (status.version) {
+            console.log(`  Version: ${status.version}`);
+        }
+        if (pid) {
+            console.log(`  PID: ${pid}`);
+        }
+        if (nodeCount !== undefined && edgeCount !== undefined) {
+            console.log(`  Nodes: ${nodeCount}`);
+            console.log(`  Edges: ${edgeCount}`);
+        }
+    }
+    else {
+        console.log('RFDB server is not running');
+        console.log(`  Socket: ${socketPath}`);
+        if (existsSync(socketPath)) {
+            console.log('  (stale socket file exists)');
+        }
+    }
+});

package/dist/commands/stats.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Stats command - Show project statistics
+ */
+import { Command } from 'commander';
+export declare const statsCommand: Command;
+//# sourceMappingURL=stats.d.ts.map

package/dist/commands/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../src/commands/stats.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,eAAO,MAAM,YAAY,SA+CrB,CAAC"}

package/dist/commands/stats.js

@@ -0,0 +1,52 @@
+/**
+ * Stats command - Show project statistics
+ */
+import { Command } from 'commander';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import { RFDBServerBackend } from '@grafema/core';
+import { exitWithError } from '../utils/errorFormatter.js';
+export const statsCommand = new Command('stats')
+    .description('Show project statistics')
+    .option('-p, --project <path>', 'Project path', '.')
+    .option('-j, --json', 'Output as JSON')
+    .option('-t, --types', 'Show breakdown by type')
+    .action(async (options) => {
+    const projectPath = resolve(options.project);
+    const grafemaDir = join(projectPath, '.grafema');
+    const dbPath = join(grafemaDir, 'graph.rfdb');
+    if (!existsSync(dbPath)) {
+        exitWithError('No graph database found', ['Run: grafema analyze']);
+    }
+    const backend = new RFDBServerBackend({ dbPath });
+    await backend.connect();
+    try {
+        const stats = await backend.getStats();
+        if (options.json) {
+            console.log(JSON.stringify(stats, null, 2));
+        }
+        else {
+            console.log('Graph Statistics');
+            console.log('================');
+            console.log(`Total nodes: ${stats.nodeCount}`);
+            console.log(`Total edges: ${stats.edgeCount}`);
+            if (options.types) {
+                console.log('');
+                console.log('Nodes by type:');
+                const sortedNodes = Object.entries(stats.nodesByType).sort((a, b) => b[1] - a[1]);
+                for (const [type, count] of sortedNodes) {
+                    console.log(`  ${type}: ${count}`);
+                }
+                console.log('');
+                console.log('Edges by type:');
+                const sortedEdges = Object.entries(stats.edgesByType).sort((a, b) => b[1] - a[1]);
+                for (const [type, count] of sortedEdges) {
+                    console.log(`  ${type}: ${count}`);
+                }
+            }
+        }
+    }
+    finally {
+        await backend.close();
+    }
+});

package/dist/commands/trace.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Trace command - Data flow analysis
+ *
+ * Usage:
+ *   grafema trace "userId from authenticate"
+ *   grafema trace "config"
+ */
+import { Command } from 'commander';
+export declare const traceCommand: Command;
+//# sourceMappingURL=trace.d.ts.map

package/dist/commands/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/commands/trace.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4BpC,eAAO,MAAM,YAAY,SAuFrB,CAAC"}

package/dist/commands/trace.js

@@ -0,0 +1,270 @@
+/**
+ * Trace command - Data flow analysis
+ *
+ * Usage:
+ *   grafema trace "userId from authenticate"
+ *   grafema trace "config"
+ */
+import { Command } from 'commander';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import { RFDBServerBackend, parseSemanticId } from '@grafema/core';
+import { formatNodeDisplay, formatNodeInline } from '../utils/formatNode.js';
+import { exitWithError } from '../utils/errorFormatter.js';
+export const traceCommand = new Command('trace')
+    .description('Trace data flow for a variable')
+    .argument('<pattern>', 'Pattern: "varName from functionName" or just "varName"')
+    .option('-p, --project <path>', 'Project path', '.')
+    .option('-j, --json', 'Output as JSON')
+    .option('-d, --depth <n>', 'Max trace depth', '10')
+    .action(async (pattern, options) => {
+    const projectPath = resolve(options.project);
+    const grafemaDir = join(projectPath, '.grafema');
+    const dbPath = join(grafemaDir, 'graph.rfdb');
+    if (!existsSync(dbPath)) {
+        exitWithError('No graph database found', ['Run: grafema analyze']);
+    }
+    const backend = new RFDBServerBackend({ dbPath });
+    await backend.connect();
+    try {
+        // Parse pattern: "varName from functionName" or just "varName"
+        const { varName, scopeName } = parseTracePattern(pattern);
+        const maxDepth = parseInt(options.depth, 10);
+        console.log(`Tracing ${varName}${scopeName ? ` from ${scopeName}` : ''}...`);
+        console.log('');
+        // Find starting variable(s)
+        const variables = await findVariables(backend, varName, scopeName);
+        if (variables.length === 0) {
+            console.log(`No variable "${varName}" found${scopeName ? ` in ${scopeName}` : ''}`);
+            return;
+        }
+        // Trace each variable
+        for (const variable of variables) {
+            console.log(formatNodeDisplay(variable, { projectPath }));
+            console.log('');
+            // Trace backwards through ASSIGNED_FROM
+            const backwardTrace = await traceBackward(backend, variable.id, maxDepth);
+            if (backwardTrace.length > 0) {
+                console.log('Data sources (where value comes from):');
+                displayTrace(backwardTrace, projectPath, '  ');
+            }
+            // Trace forward through ASSIGNED_FROM (where this value flows to)
+            const forwardTrace = await traceForward(backend, variable.id, maxDepth);
+            if (forwardTrace.length > 0) {
+                console.log('');
+                console.log('Data sinks (where value flows to):');
+                displayTrace(forwardTrace, projectPath, '  ');
+            }
+            // Show value domain if available
+            const sources = await getValueSources(backend, variable.id);
+            if (sources.length > 0) {
+                console.log('');
+                console.log('Possible values:');
+                for (const src of sources) {
+                    if (src.type === 'LITERAL' && src.value !== undefined) {
+                        console.log(`  • ${JSON.stringify(src.value)} (literal)`);
+                    }
+                    else if (src.type === 'PARAMETER') {
+                        console.log(`  • <parameter ${src.name}> (runtime input)`);
+                    }
+                    else if (src.type === 'CALL') {
+                        console.log(`  • <return from ${src.name || 'call'}> (computed)`);
+                    }
+                    else {
+                        console.log(`  • <${src.type.toLowerCase()}> ${src.name || ''}`);
+                    }
+                }
+            }
+            if (variables.length > 1) {
+                console.log('');
+                console.log('---');
+            }
+        }
+        if (options.json) {
+            // TODO: structured JSON output
+        }
+    }
+    finally {
+        await backend.close();
+    }
+});
+/**
+ * Parse trace pattern
+ */
+function parseTracePattern(pattern) {
+    const fromMatch = pattern.match(/^(.+?)\s+from\s+(.+)$/i);
+    if (fromMatch) {
+        return { varName: fromMatch[1].trim(), scopeName: fromMatch[2].trim() };
+    }
+    return { varName: pattern.trim(), scopeName: null };
+}
+/**
+ * Find variables by name, optionally scoped to a function
+ */
+async function findVariables(backend, varName, scopeName) {
+    const results = [];
+    const lowerScopeName = scopeName ? scopeName.toLowerCase() : null;
+    // Search VARIABLE, CONSTANT, PARAMETER
+    for (const nodeType of ['VARIABLE', 'CONSTANT', 'PARAMETER']) {
+        for await (const node of backend.queryNodes({ nodeType: nodeType })) {
+            const name = node.name || '';
+            if (name.toLowerCase() === varName.toLowerCase()) {
+                // If scope specified, check if variable is in that scope
+                if (scopeName) {
+                    const parsed = parseSemanticId(node.id);
+                    if (!parsed)
+                        continue; // Skip nodes with invalid IDs
+                    // Check if scopeName appears anywhere in the scope chain
+                    if (!parsed.scopePath.some(s => s.toLowerCase() === lowerScopeName)) {
+                        continue;
+                    }
+                }
+                results.push({
+                    id: node.id,
+                    type: node.type || nodeType,
+                    name: name,
+                    file: node.file || '',
+                    line: node.line,
+                });
+                if (results.length >= 5)
+                    break;
+            }
+        }
+        if (results.length >= 5)
+            break;
+    }
+    return results;
+}
+/**
+ * Trace backward through ASSIGNED_FROM edges
+ */
+async function traceBackward(backend, startId, maxDepth) {
+    const trace = [];
+    const visited = new Set();
+    const queue = [{ id: startId, depth: 0 }];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (visited.has(id) || depth > maxDepth)
+            continue;
+        visited.add(id);
+        try {
+            const edges = await backend.getOutgoingEdges(id, ['ASSIGNED_FROM', 'DERIVES_FROM']);
+            for (const edge of edges) {
+                const targetNode = await backend.getNode(edge.dst);
+                if (!targetNode)
+                    continue;
+                const nodeInfo = {
+                    id: targetNode.id,
+                    type: targetNode.type || 'UNKNOWN',
+                    name: targetNode.name || '',
+                    file: targetNode.file || '',
+                    line: targetNode.line,
+                    value: targetNode.value,
+                };
+                trace.push({
+                    node: nodeInfo,
+                    edgeType: edge.edgeType || edge.type,
+                    depth: depth + 1,
+                });
+                // Continue tracing unless we hit a leaf
+                const leafTypes = ['LITERAL', 'PARAMETER', 'EXTERNAL_MODULE'];
+                if (!leafTypes.includes(nodeInfo.type)) {
+                    queue.push({ id: targetNode.id, depth: depth + 1 });
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return trace;
+}
+/**
+ * Trace forward - find what uses this variable
+ */
+async function traceForward(backend, startId, maxDepth) {
+    const trace = [];
+    const visited = new Set();
+    const queue = [{ id: startId, depth: 0 }];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (visited.has(id) || depth > maxDepth)
+            continue;
+        visited.add(id);
+        try {
+            // Find nodes that get their value FROM this node
+            const edges = await backend.getIncomingEdges(id, ['ASSIGNED_FROM', 'DERIVES_FROM']);
+            for (const edge of edges) {
+                const sourceNode = await backend.getNode(edge.src);
+                if (!sourceNode)
+                    continue;
+                const nodeInfo = {
+                    id: sourceNode.id,
+                    type: sourceNode.type || 'UNKNOWN',
+                    name: sourceNode.name || '',
+                    file: sourceNode.file || '',
+                    line: sourceNode.line,
+                };
+                trace.push({
+                    node: nodeInfo,
+                    edgeType: edge.edgeType || edge.type,
+                    depth: depth + 1,
+                });
+                // Continue forward
+                if (depth < maxDepth - 1) {
+                    queue.push({ id: sourceNode.id, depth: depth + 1 });
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return trace;
+}
+/**
+ * Get immediate value sources (for "possible values" display)
+ */
+async function getValueSources(backend, nodeId) {
+    const sources = [];
+    try {
+        const edges = await backend.getOutgoingEdges(nodeId, ['ASSIGNED_FROM']);
+        for (const edge of edges.slice(0, 5)) {
+            const node = await backend.getNode(edge.dst);
+            if (node) {
+                sources.push({
+                    id: node.id,
+                    type: node.type || 'UNKNOWN',
+                    name: node.name || '',
+                    file: node.file || '',
+                    line: node.line,
+                    value: node.value,
+                });
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return sources;
+}
+/**
+ * Display trace results with semantic IDs
+ */
+function displayTrace(trace, _projectPath, indent) {
+    // Group by depth
+    const byDepth = new Map();
+    for (const step of trace) {
+        if (!byDepth.has(step.depth)) {
+            byDepth.set(step.depth, []);
+        }
+        byDepth.get(step.depth).push(step);
+    }
+    for (const [_depth, steps] of [...byDepth.entries()].sort((a, b) => a[0] - b[0])) {
+        for (const step of steps) {
+            const valueStr = step.node.value !== undefined ? ` = ${JSON.stringify(step.node.value)}` : '';
+            console.log(`${indent}<- ${step.node.name || step.node.type} (${step.node.type})${valueStr}`);
+            console.log(`${indent}   ${formatNodeInline(step.node)}`);
+        }
+    }
+}

package/dist/utils/codePreview.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Code Preview Utility
+ *
+ * Reads source files and extracts code snippets around a given line number
+ * for displaying in the explorer UI.
+ */
+export interface CodePreviewOptions {
+    file: string;
+    line: number;
+    contextBefore?: number;
+    contextAfter?: number;
+}
+export interface CodePreviewResult {
+    lines: string[];
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Get a code preview snippet from a source file.
+ * Returns lines around the specified line number with context.
+ */
+export declare function getCodePreview(options: CodePreviewOptions): CodePreviewResult | null;
+/**
+ * Format code preview lines with line numbers for display.
+ * Returns an array of formatted strings like "  42 | code here"
+ */
+export declare function formatCodePreview(preview: CodePreviewResult, highlightLine?: number): string[];
+//# sourceMappingURL=codePreview.d.ts.map

package/dist/utils/codePreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codePreview.d.ts","sourceRoot":"","sources":["../../src/utils/codePreview.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,GAAG,IAAI,CA0BpF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,iBAAiB,EAC1B,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,EAAE,CAeV"}