@grafema/cli 0.1.1-alpha → 0.2.1-beta

package/dist/commands/doctor/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for `grafema doctor` command - REG-214
+ */
+export {};

package/dist/commands/doctor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Doctor command - Diagnose Grafema setup issues
+ *
+ * Checks (in order):
+ * 1. Initialization (.grafema directory, config file)
+ * 2. Config validity (syntax, plugin names)
+ * 3. Entrypoints (service paths exist)
+ * 4. Server status (RFDB server running)
+ * 5. Database exists and has data
+ * 6. Graph statistics
+ * 7. Graph connectivity
+ * 8. Graph freshness
+ * 9. Version information
+ */
+import { Command } from 'commander';
+export declare const doctorCommand: Command;
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,eAAO,MAAM,aAAa,SA6DtB,CAAC"}

package/dist/commands/doctor.js

@@ -0,0 +1,80 @@
+/**
+ * Doctor command - Diagnose Grafema setup issues
+ *
+ * Checks (in order):
+ * 1. Initialization (.grafema directory, config file)
+ * 2. Config validity (syntax, plugin names)
+ * 3. Entrypoints (service paths exist)
+ * 4. Server status (RFDB server running)
+ * 5. Database exists and has data
+ * 6. Graph statistics
+ * 7. Graph connectivity
+ * 8. Graph freshness
+ * 9. Version information
+ */
+import { Command } from 'commander';
+import { resolve } from 'path';
+import { checkGrafemaInitialized, checkServerStatus, checkConfigValidity, checkEntrypoints, checkDatabaseExists, checkGraphStats, checkConnectivity, checkFreshness, checkVersions, } from './doctor/checks.js';
+import { formatReport, buildJsonReport } from './doctor/output.js';
+export const doctorCommand = new Command('doctor')
+    .description('Diagnose Grafema setup issues')
+    .option('-p, --project <path>', 'Project path', '.')
+    .option('-j, --json', 'Output as JSON')
+    .option('-q, --quiet', 'Only show failures')
+    .option('-v, --verbose', 'Show detailed diagnostics')
+    .addHelpText('after', `
+Examples:
+  grafema doctor                 Run all diagnostic checks
+  grafema doctor --verbose       Show detailed diagnostics
+  grafema doctor --quiet         Only show failures
+  grafema doctor --json          Output diagnostics as JSON
+`)
+    .action(async (options) => {
+    const projectPath = resolve(options.project);
+    const checks = [];
+    // Level 1: Prerequisites (fail-fast)
+    const initCheck = await checkGrafemaInitialized(projectPath);
+    checks.push(initCheck);
+    if (initCheck.status === 'fail') {
+        // Can't continue without initialization
+        outputResults(checks, projectPath, options);
+        process.exit(1);
+    }
+    // Level 2: Configuration
+    checks.push(await checkConfigValidity(projectPath));
+    checks.push(await checkEntrypoints(projectPath));
+    // Server status (needed for Level 3 checks)
+    const serverCheck = await checkServerStatus(projectPath);
+    checks.push(serverCheck);
+    // Level 3: Graph Health (requires database and optionally server)
+    checks.push(await checkDatabaseExists(projectPath));
+    if (serverCheck.status === 'pass') {
+        // Server is running - can do full health checks
+        checks.push(await checkGraphStats(projectPath));
+        checks.push(await checkConnectivity(projectPath));
+        checks.push(await checkFreshness(projectPath));
+    }
+    // Level 4: Informational
+    checks.push(await checkVersions(projectPath));
+    // Output results
+    outputResults(checks, projectPath, options);
+    // Exit code
+    const failCount = checks.filter(c => c.status === 'fail').length;
+    const warnCount = checks.filter(c => c.status === 'warn').length;
+    if (failCount > 0) {
+        process.exit(1); // Critical issues
+    }
+    else if (warnCount > 0) {
+        process.exit(2); // Warnings only
+    }
+    // Exit 0 for all pass
+});
+function outputResults(checks, projectPath, options) {
+    if (options.json) {
+        const report = buildJsonReport(checks, projectPath);
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(formatReport(checks, options));
+    }
+}

package/dist/commands/explain.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Explain command - Show what nodes exist in a file
+ *
+ * Purpose: Help users discover what nodes exist in the graph for a file,
+ * displaying semantic IDs so users can query them.
+ *
+ * Use cases:
+ * - User can't find a variable they expect to be in the graph
+ * - User wants to understand what's been analyzed for a file
+ * - User needs semantic IDs to construct queries
+ *
+ * @see _tasks/REG-177/006-don-revised-plan.md
+ */
+import { Command } from 'commander';
+export declare const explainCommand: Command;
+//# sourceMappingURL=explain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"explain.d.ts","sourceRoot":"","sources":["../../src/commands/explain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,eAAO,MAAM,cAAc,SA+GvB,CAAC"}

package/dist/commands/explain.js

@@ -0,0 +1,145 @@
+/**
+ * Explain command - Show what nodes exist in a file
+ *
+ * Purpose: Help users discover what nodes exist in the graph for a file,
+ * displaying semantic IDs so users can query them.
+ *
+ * Use cases:
+ * - User can't find a variable they expect to be in the graph
+ * - User wants to understand what's been analyzed for a file
+ * - User needs semantic IDs to construct queries
+ *
+ * @see _tasks/REG-177/006-don-revised-plan.md
+ */
+import { Command } from 'commander';
+import { resolve, join, relative, normalize } from 'path';
+import { existsSync, realpathSync } from 'fs';
+import { RFDBServerBackend, FileExplainer } from '@grafema/core';
+import { exitWithError } from '../utils/errorFormatter.js';
+export const explainCommand = new Command('explain')
+    .description('Show what nodes exist in a file')
+    .argument('<file>', 'File path to explain')
+    .option('-p, --project <path>', 'Project path', '.')
+    .option('-j, --json', 'Output as JSON')
+    .addHelpText('after', `
+Examples:
+  grafema explain src/app.ts           Show all nodes in src/app.ts
+  grafema explain src/app.ts --json    Output as JSON for scripting
+  grafema explain ./src/utils.js       Works with relative paths
+
+This command helps you:
+  1. Discover what nodes exist in the graph for a file
+  2. Find semantic IDs to use in queries
+  3. Understand scope context (try/catch, conditionals, etc.)
+
+If a file shows NOT_ANALYZED:
+  - Run: grafema analyze
+  - Check if file is excluded in config
+`)
+    .action(async (file, options) => {
+    const projectPath = resolve(options.project);
+    const grafemaDir = join(projectPath, '.grafema');
+    const dbPath = join(grafemaDir, 'graph.rfdb');
+    // Check database exists
+    if (!existsSync(dbPath)) {
+        exitWithError('No graph database found', [
+            'Run: grafema init && grafema analyze',
+        ]);
+    }
+    // Normalize and resolve file path
+    let filePath = file;
+    // Handle relative paths - convert to relative from project root
+    if (file.startsWith('./') || file.startsWith('../')) {
+        filePath = normalize(file).replace(/^\.\//, '');
+    }
+    else if (resolve(file) === file) {
+        // Absolute path - convert to relative
+        filePath = relative(projectPath, file);
+    }
+    // Resolve to absolute path for graph lookup
+    const resolvedPath = resolve(projectPath, filePath);
+    if (!existsSync(resolvedPath)) {
+        exitWithError(`File not found: ${file}`, [
+            'Check the file path and try again',
+        ]);
+    }
+    // Use realpath to match how graph stores paths (handles symlinks like /tmp -> /private/tmp on macOS)
+    const absoluteFilePath = realpathSync(resolvedPath);
+    // Keep relative path for display
+    const relativeFilePath = relative(projectPath, absoluteFilePath);
+    const backend = new RFDBServerBackend({ dbPath });
+    await backend.connect();
+    try {
+        const explainer = new FileExplainer(backend);
+        // Query with absolute path since graph stores absolute paths
+        const result = await explainer.explain(absoluteFilePath);
+        // Override file in result for display purposes (show relative path)
+        result.file = relativeFilePath;
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        // Human-readable output
+        console.log(`File: ${result.file}`);
+        console.log(`Status: ${result.status}`);
+        console.log('');
+        if (result.status === 'NOT_ANALYZED') {
+            console.log('This file has not been analyzed yet.');
+            console.log('');
+            console.log('To analyze:');
+            console.log('  grafema analyze');
+            return;
+        }
+        console.log(`Nodes in graph: ${result.totalCount}`);
+        console.log('');
+        // Group nodes by type for display
+        const nodesByType = groupNodesByType(result.nodes);
+        for (const [type, nodes] of Object.entries(nodesByType)) {
+            for (const node of nodes) {
+                displayNode(node, type, projectPath);
+                console.log('');
+            }
+        }
+        // Show summary by type
+        console.log('Summary:');
+        for (const [type, count] of Object.entries(result.byType).sort()) {
+            console.log(`  ${type}: ${count}`);
+        }
+        console.log('');
+        console.log('To query a specific node by ID:');
+        console.log('  grafema query --raw \'attr(X, "id", "<semantic-id>")\'');
+    }
+    finally {
+        await backend.close();
+    }
+});
+/**
+ * Group nodes by type for organized display
+ */
+function groupNodesByType(nodes) {
+    const grouped = {};
+    for (const node of nodes) {
+        const type = node.type || 'UNKNOWN';
+        if (!grouped[type]) {
+            grouped[type] = [];
+        }
+        grouped[type].push(node);
+    }
+    return grouped;
+}
+/**
+ * Display a single node in human-readable format
+ */
+function displayNode(node, type, projectPath) {
+    // Line 1: [TYPE] name (context)
+    const contextSuffix = node.context ? ` (${node.context})` : '';
+    console.log(`[${type}] ${node.name || '<anonymous>'}${contextSuffix}`);
+    // Line 2: ID (semantic ID for querying)
+    console.log(`  ID: ${node.id}`);
+    // Line 3: Location
+    if (node.file) {
+        const relPath = relative(projectPath, node.file);
+        const loc = node.line ? `${relPath}:${node.line}` : relPath;
+        console.log(`  Location: ${loc}`);
+    }
+}

package/dist/commands/explore.d.ts

@@ -1,5 +1,11 @@
 /**
- * Explore command - Interactive TUI for graph navigation
+ * Explore command - Interactive TUI or batch mode for graph navigation
+ *
+ * Interactive mode: grafema explore [start]
+ * Batch mode:
+ *   grafema explore --query "functionName"
+ *   grafema explore --callers "functionName"
+ *   grafema explore --callees "functionName"
  */
 import { Command } from 'commander';
 export declare const exploreCommand: Command;

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

@@ -1 +1 @@
-{"version":3,"file":"explore.d.ts","sourceRoot":"","sources":["../../src/commands/explore.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2/BpC,eAAO,MAAM,cAAc,SAgCvB,CAAC"}
+{"version":3,"file":"explore.d.ts","sourceRoot":"","sources":["../../src/commands/explore.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAomCpC,eAAO,MAAM,cAAc,SAuEvB,CAAC"}

package/dist/commands/explore.js

@@ -1,6 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * Explore command - Interactive TUI for graph navigation
+ * Explore command - Interactive TUI or batch mode for graph navigation
+ *
+ * Interactive mode: grafema explore [start]
+ * Batch mode:
+ *   grafema explore --query "functionName"
+ *   grafema explore --callers "functionName"
+ *   grafema explore --callees "functionName"
  */
 import { Command } from 'commander';
 import { resolve, join, relative } from 'path';
@@ -8,7 +14,7 @@ import { existsSync } from 'fs';
 import { execSync } from 'child_process';
 import { useState, useEffect } from 'react';
 import { render, Box, Text, useInput, useApp } from 'ink';
-import { RFDBServerBackend } from '@grafema/core';
+import { RFDBServerBackend, findContainingFunction as findContainingFunctionCore, findCallsInFunction as findCallsInFunctionCore } from '@grafema/core';
 import { getCodePreview, formatCodePreview } from '../utils/codePreview.js';
 import { exitWithError } from '../utils/errorFormatter.js';
 // Main Explorer Component
@@ -396,10 +402,16 @@ async function getCallers(backend, nodeId, limit) {
             const callNode = await backend.getNode(edge.src);
             if (!callNode)
                 continue;
-            const containingFunc = await findContainingFunction(backend, callNode.id);
+            const containingFunc = await findContainingFunctionCore(backend, callNode.id);
             if (containingFunc && !seen.has(containingFunc.id)) {
                 seen.add(containingFunc.id);
-                callers.push(containingFunc);
+                callers.push({
+                    id: containingFunc.id,
+                    type: containingFunc.type,
+                    name: containingFunc.name,
+                    file: containingFunc.file || '',
+                    line: containingFunc.line,
+                });
             }
         }
     }
@@ -412,19 +424,21 @@ async function getCallees(backend, nodeId, limit) {
     const callees = [];
     const seen = new Set();
     try {
-        const callNodes = await findCallsInFunction(backend, nodeId);
-        for (const callNode of callNodes) {
+        // Use shared utility from @grafema/core
+        const calls = await findCallsInFunctionCore(backend, nodeId);
+        for (const call of calls) {
             if (callees.length >= limit)
                 break;
-            const callEdges = await backend.getOutgoingEdges(callNode.id, ['CALLS']);
-            for (const edge of callEdges) {
-                if (callees.length >= limit)
-                    break;
-                const targetNode = await backend.getNode(edge.dst);
-                if (!targetNode || seen.has(targetNode.id))
-                    continue;
-                seen.add(targetNode.id);
-                callees.push(extractNodeInfo(targetNode));
+            // Only include resolved calls with targets
+            if (call.resolved && call.target && !seen.has(call.target.id)) {
+                seen.add(call.target.id);
+                callees.push({
+                    id: call.target.id,
+                    type: 'FUNCTION',
+                    name: call.target.name || '',
+                    file: call.target.file || '',
+                    line: call.target.line,
+                });
             }
         }
     }
@@ -433,72 +447,6 @@ async function getCallees(backend, nodeId, limit) {
     }
     return callees;
 }
-async function findContainingFunction(backend, nodeId) {
-    const visited = new Set();
-    const queue = [{ id: nodeId, depth: 0 }];
-    while (queue.length > 0) {
-        const { id, depth } = queue.shift();
-        if (visited.has(id) || depth > 15)
-            continue;
-        visited.add(id);
-        try {
-            const edges = await backend.getIncomingEdges(id, null);
-            for (const edge of edges) {
-                const edgeType = edge.edgeType || edge.type;
-                if (!['CONTAINS', 'HAS_SCOPE', 'DECLARES'].includes(edgeType))
-                    continue;
-                const parent = await backend.getNode(edge.src);
-                if (!parent || visited.has(parent.id))
-                    continue;
-                const parentType = parent.type || parent.nodeType;
-                if (parentType === 'FUNCTION' || parentType === 'CLASS' || parentType === 'MODULE') {
-                    return extractNodeInfo(parent);
-                }
-                queue.push({ id: parent.id, depth: depth + 1 });
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-    return null;
-}
-async function findCallsInFunction(backend, nodeId) {
-    const calls = [];
-    const visited = new Set();
-    const queue = [{ id: nodeId, depth: 0 }];
-    while (queue.length > 0) {
-        const { id, depth } = queue.shift();
-        if (visited.has(id) || depth > 10)
-            continue;
-        visited.add(id);
-        try {
-            const edges = await backend.getOutgoingEdges(id, ['CONTAINS']);
-            for (const edge of edges) {
-                const child = await backend.getNode(edge.dst);
-                if (!child)
-                    continue;
-                const childType = child.type || child.nodeType;
-                if (childType === 'CALL') {
-                    calls.push({
-                        id: child.id,
-                        type: 'CALL',
-                        name: child.name || '',
-                        file: child.file || '',
-                        line: child.line,
-                    });
-                }
-                if (childType !== 'FUNCTION' && childType !== 'CLASS') {
-                    queue.push({ id: child.id, depth: depth + 1 });
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-    return calls;
-}
 async function searchNode(backend, query) {
     const results = await searchNodes(backend, query, 1);
     return results[0] || null;
@@ -608,21 +556,192 @@ async function findStartNode(backend, startName) {
     }
     return bestNode;
 }
-// Command
+// =============================================================================
+// Batch Mode Implementation
+// =============================================================================
+/**
+ * Run explore in batch mode - for AI agents, CI, and scripts
+ */
+async function runBatchExplore(backend, options, projectPath) {
+    const depth = parseInt(options.depth || '3', 10) || 3;
+    const useJson = options.json || options.format === 'json' || options.format !== 'text';
+    try {
+        if (options.query) {
+            // Search mode
+            const results = await searchNodes(backend, options.query, 20);
+            outputResults(results, 'search', useJson, projectPath);
+        }
+        else if (options.callers) {
+            // Callers mode
+            const target = await searchNode(backend, options.callers);
+            if (!target) {
+                exitWithError(`Function "${options.callers}" not found`, [
+                    'Try: grafema query "partial-name"',
+                ]);
+            }
+            const callers = await getCallersRecursive(backend, target.id, depth);
+            outputResults(callers, 'callers', useJson, projectPath, target);
+        }
+        else if (options.callees) {
+            // Callees mode
+            const target = await searchNode(backend, options.callees);
+            if (!target) {
+                exitWithError(`Function "${options.callees}" not found`, [
+                    'Try: grafema query "partial-name"',
+                ]);
+            }
+            const callees = await getCalleesRecursive(backend, target.id, depth);
+            outputResults(callees, 'callees', useJson, projectPath, target);
+        }
+    }
+    catch (err) {
+        exitWithError(`Explore failed: ${err.message}`);
+    }
+}
+/**
+ * Output results in JSON or text format
+ */
+function outputResults(nodes, mode, useJson, projectPath, target) {
+    if (useJson) {
+        const output = {
+            mode,
+            target: target ? formatNodeForJson(target, projectPath) : undefined,
+            count: nodes.length,
+            results: nodes.map(n => formatNodeForJson(n, projectPath)),
+        };
+        console.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        // Text format
+        if (target) {
+            console.log(`${mode === 'callers' ? 'Callers of' : 'Callees of'}: ${target.name}`);
+            console.log(`File: ${relative(projectPath, target.file)}${target.line ? `:${target.line}` : ''}`);
+            console.log('');
+        }
+        if (nodes.length === 0) {
+            console.log(`  (no ${mode} found)`);
+        }
+        else {
+            for (const node of nodes) {
+                const loc = relative(projectPath, node.file);
+                console.log(`  ${node.type} ${node.name} (${loc}${node.line ? `:${node.line}` : ''})`);
+            }
+        }
+        console.log('');
+        console.log(`Total: ${nodes.length}`);
+    }
+}
+function formatNodeForJson(node, projectPath) {
+    return {
+        id: node.id,
+        type: node.type,
+        name: node.name,
+        file: relative(projectPath, node.file),
+        line: node.line,
+        async: node.async,
+        exported: node.exported,
+    };
+}
+/**
+ * Get callers recursively up to specified depth
+ */
+async function getCallersRecursive(backend, nodeId, maxDepth) {
+    const results = [];
+    const visited = new Set();
+    const queue = [{ id: nodeId, depth: 0 }];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (visited.has(id) || depth > maxDepth)
+            continue;
+        visited.add(id);
+        const callers = await getCallers(backend, id, 50);
+        for (const caller of callers) {
+            if (!visited.has(caller.id)) {
+                results.push(caller);
+                if (depth < maxDepth) {
+                    queue.push({ id: caller.id, depth: depth + 1 });
+                }
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Get callees recursively up to specified depth
+ */
+async function getCalleesRecursive(backend, nodeId, maxDepth) {
+    const results = [];
+    const visited = new Set();
+    const queue = [{ id: nodeId, depth: 0 }];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (visited.has(id) || depth > maxDepth)
+            continue;
+        visited.add(id);
+        const callees = await getCallees(backend, id, 50);
+        for (const callee of callees) {
+            if (!visited.has(callee.id)) {
+                results.push(callee);
+                if (depth < maxDepth) {
+                    queue.push({ id: callee.id, depth: depth + 1 });
+                }
+            }
+        }
+    }
+    return results;
+}
+// =============================================================================
+// Command Definition
+// =============================================================================
 export const exploreCommand = new Command('explore')
-    .description('Interactive graph navigation')
-    .argument('[start]', 'Starting function name')
+    .description('Interactive graph navigation (TUI) or batch query mode')
+    .argument('[start]', 'Starting function name (for interactive mode)')
     .option('-p, --project <path>', 'Project path', '.')
+    .option('-q, --query <name>', 'Batch: search for nodes by name')
+    .option('--callers <name>', 'Batch: show callers of function')
+    .option('--callees <name>', 'Batch: show callees of function')
+    .option('-d, --depth <n>', 'Batch: traversal depth', '3')
+    .option('-j, --json', 'Output as JSON (default for batch mode)')
+    .option('--format <type>', 'Output format: json or text')
+    .addHelpText('after', `
+Examples:
+  grafema explore                        Interactive TUI mode
+  grafema explore "authenticate"         Start TUI at specific function
+  grafema explore --query "User"         Batch: search for nodes
+  grafema explore --callers "login"      Batch: show who calls login
+  grafema explore --callees "main"       Batch: show what main calls
+  grafema explore --callers "auth" -d 5  Batch: callers with depth 5
+  grafema explore --query "api" --format text   Batch: text output
+`)
     .action(async (start, 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']);
+        exitWithError('No database found', [
+            'Run: grafema analyze',
+        ]);
     }
     const backend = new RFDBServerBackend({ dbPath });
     try {
         await backend.connect();
+        // Detect batch mode
+        const isBatchMode = !!(options.query || options.callers || options.callees);
+        if (isBatchMode) {
+            await runBatchExplore(backend, options, projectPath);
+            return;
+        }
+        // Interactive mode - check TTY
+        const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+        if (!isTTY) {
+            exitWithError('Interactive mode requires a terminal', [
+                'Batch mode: grafema explore --query "functionName"',
+                'Batch mode: grafema explore --callers "functionName"',
+                'Batch mode: grafema explore --callees "functionName"',
+                'Alternative: grafema query "functionName"',
+                'Alternative: grafema impact "functionName"',
+            ]);
+        }
         const startNode = await findStartNode(backend, start || null);
         const { waitUntilExit } = render(_jsx(Explorer, { backend: backend, startNode: startNode, projectPath: projectPath }));
         await waitUntilExit();

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

@@ -1 +1 @@
-{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../src/commands/get.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkCpC,eAAO,MAAM,UAAU,SAyCnB,CAAC"}
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../src/commands/get.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoCpC,eAAO,MAAM,UAAU,SAgDnB,CAAC"}