@grafema/cli 0.2.5-beta → 0.2.7

package/src/commands/analyzeAction.ts

@@ -0,0 +1,284 @@
+/**
+ * Analyze command action — connects to RFDB, loads plugins, runs Orchestrator.
+ *
+ * Extracted from analyze.ts (REG-435) to keep command definition separate
+ * from execution logic.
+ */
+
+import { resolve, join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import {
+  Orchestrator,
+  RFDBServerBackend,
+  DiagnosticReporter,
+  DiagnosticWriter,
+  createLogger,
+  loadConfig,
+  StrictModeFailure,
+} from '@grafema/core';
+import type { LogLevel, GraphBackend } from '@grafema/types';
+import { ProgressRenderer } from '../utils/progressRenderer.js';
+import { loadCustomPlugins, createPlugins } from '../plugins/pluginLoader.js';
+
+export interface NodeEdgeCountBackend {
+  nodeCount: () => Promise<number>;
+  edgeCount: () => Promise<number>;
+}
+
+export async function fetchNodeEdgeCounts(backend: NodeEdgeCountBackend): Promise<{ nodeCount: number; edgeCount: number }> {
+  const [nodeCount, edgeCount] = await Promise.all([backend.nodeCount(), backend.edgeCount()]);
+  return { nodeCount, edgeCount };
+}
+
+export function exitWithCode(code: number, exitFn: (code: number) => void = process.exit): void {
+  exitFn(code);
+}
+
+/**
+ * Determine log level from CLI options.
+ * Priority: --log-level > --quiet > --verbose > default ('silent')
+ *
+ * By default, logs are silent to allow clean progress UI.
+ * Use --verbose to see detailed logs (disables interactive progress).
+ */
+function getLogLevel(options: { quiet?: boolean; verbose?: boolean; logLevel?: string }): LogLevel {
+  if (options.logLevel) {
+    const validLevels: LogLevel[] = ['silent', 'errors', 'warnings', 'info', 'debug'];
+    if (validLevels.includes(options.logLevel as LogLevel)) {
+      return options.logLevel as LogLevel;
+    }
+  }
+  if (options.quiet) return 'silent';
+  if (options.verbose) return 'info';  // --verbose shows logs instead of progress UI
+  return 'silent';  // Default: silent logs, clean progress UI
+}
+
+export async function analyzeAction(path: string, options: { service?: string; entrypoint?: string; clear?: boolean; quiet?: boolean; verbose?: boolean; debug?: boolean; logLevel?: string; logFile?: string; strict?: boolean; autoStart?: boolean }): Promise<void> {
+  const projectPath = resolve(path);
+  const grafemaDir = join(projectPath, '.grafema');
+  const dbPath = join(grafemaDir, 'graph.rfdb');
+
+  if (!existsSync(grafemaDir)) {
+    mkdirSync(grafemaDir, { recursive: true });
+  }
+
+  // Two log levels for CLI output:
+  // - info: important results (shows unless --quiet)
+  // - debug: verbose details (shows only with --verbose)
+  const info = options.quiet ? () => {} : console.log;
+  const debug = options.verbose ? console.log : () => {};
+
+  // Create logger based on CLI flags
+  const logLevel = getLogLevel(options);
+  const logFile = options.logFile ? resolve(options.logFile) : undefined;
+  const logger = createLogger(logLevel, logFile ? { logFile } : undefined);
+
+  if (logFile) {
+    debug(`Log file: ${logFile}`);
+  }
+  debug(`Analyzing project: ${projectPath}`);
+
+  // Connect to RFDB server
+  // Default: require explicit `grafema server start`
+  // Use --auto-start for CI or backwards compatibility
+  // In normal mode (not verbose), suppress backend logs for clean progress UI
+  const backend = new RFDBServerBackend({
+    dbPath,
+    autoStart: options.autoStart ?? false,
+    silent: !options.verbose  // Silent in normal mode (show progress), verbose shows logs
+  });
+
+  try {
+    await backend.connect();
+  } catch (err) {
+    if (!options.autoStart && err instanceof Error && err.message.includes('not running')) {
+      console.error('');
+      console.error('RFDB server is not running.');
+      console.error('');
+      console.error('Start the server first:');
+      console.error('  grafema server start');
+      console.error('');
+      console.error('Or use --auto-start flag:');
+      console.error('  grafema analyze --auto-start');
+      console.error('');
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  if (options.clear) {
+    debug('Clearing existing database...');
+    await backend.clear();
+  }
+
+  const config = loadConfig(projectPath, logger);
+
+  // Extract services from config (REG-174)
+  if (config.services.length > 0) {
+    debug(`Loaded ${config.services.length} service(s) from config`);
+    for (const svc of config.services) {
+      const entry = svc.entryPoint ? ` (entry: ${svc.entryPoint})` : '';
+      debug(`  - ${svc.name}: ${svc.path}${entry}`);
+    }
+  }
+
+  // Load custom plugins from .grafema/plugins/
+  const customPlugins = await loadCustomPlugins(projectPath, debug);
+  const plugins = createPlugins(config.plugins, customPlugins, options.verbose);
+
+  debug(`Loaded ${plugins.length} plugins`);
+
+  // Resolve strict mode: CLI flag overrides config
+  const strictMode = options.strict ?? config.strict ?? false;
+  if (strictMode) {
+    debug('Strict mode enabled - analysis will fail on unresolved references');
+  }
+
+  const startTime = Date.now();
+
+  // Create progress renderer for CLI output
+  // In quiet mode, use a no-op renderer (skip rendering)
+  // In verbose mode, use non-interactive (newlines per update)
+  // In normal mode, use interactive (spinner with line overwrite)
+  const renderer = options.quiet
+    ? null
+    : new ProgressRenderer({
+        isInteractive: !options.verbose && process.stdout.isTTY,
+      });
+
+  // Poll graph stats periodically to show node/edge counts in progress
+  let statsInterval: NodeJS.Timeout | null = null;
+  if (renderer && !options.quiet) {
+    statsInterval = setInterval(async () => {
+      try {
+        const stats = await fetchNodeEdgeCounts(backend);
+        renderer.setStats(stats.nodeCount, stats.edgeCount);
+      } catch {
+        // Ignore stats errors during analysis
+      }
+    }, 500); // Poll every 500ms
+    statsInterval.unref?.();
+  }
+
+  const orchestrator = new Orchestrator({
+    graph: backend as unknown as GraphBackend,
+    plugins,
+    serviceFilter: options.service || null,
+    entrypoint: options.entrypoint,
+    forceAnalysis: options.clear || false,
+    logger,
+    services: config.services.length > 0 ? config.services : undefined,  // Pass config services (REG-174)
+    strictMode, // REG-330: Pass strict mode flag
+    onProgress: (progress) => {
+      renderer?.update(progress);
+    },
+  });
+
+  let exitCode = 0;
+
+  try {
+    await orchestrator.run(projectPath);
+    await backend.flush();
+
+    const elapsedSeconds = (Date.now() - startTime) / 1000;
+    const stats = await fetchNodeEdgeCounts(backend);
+
+    // Clear progress line in interactive mode, then show results
+    if (renderer && process.stdout.isTTY) {
+      process.stdout.write('\r\x1b[K'); // Clear line
+    }
+    info('');
+    info(renderer ? renderer.finish(elapsedSeconds) : `Analysis complete in ${elapsedSeconds.toFixed(2)}s`);
+    info(`  Nodes: ${stats.nodeCount}`);
+    info(`  Edges: ${stats.edgeCount}`);
+
+    // Get diagnostics and report summary
+    const diagnostics = orchestrator.getDiagnostics();
+    const reporter = new DiagnosticReporter(diagnostics);
+
+    // Print summary if there are any issues
+    if (diagnostics.count() > 0) {
+      info('');
+      info(reporter.categorizedSummary());
+
+      // In verbose mode, print full report
+      if (options.verbose) {
+        debug('');
+        debug(reporter.report({ format: 'text', includeSummary: false }));
+      }
+    }
+
+    // Always write diagnostics.log (required for `grafema check` command)
+    const writer = new DiagnosticWriter();
+    await writer.write(diagnostics, grafemaDir);
+    if (options.debug) {
+      debug(`Diagnostics written to ${writer.getLogPath(grafemaDir)}`);
+    }
+
+    // Determine exit code based on severity
+    if (diagnostics.hasFatal()) {
+      exitCode = 1;
+    } else if (diagnostics.hasErrors()) {
+      exitCode = 2; // Completed with errors
+    } else {
+      exitCode = 0; // Success (maybe warnings)
+    }
+  } catch (e) {
+    const diagnostics = orchestrator.getDiagnostics();
+    const reporter = new DiagnosticReporter(diagnostics);
+
+    // Clear progress line in interactive mode
+    if (renderer && process.stdout.isTTY) {
+      process.stdout.write('\r\x1b[K');
+    }
+
+    // Check if this is a strict mode failure (REG-332: structured output)
+    if (e instanceof StrictModeFailure) {
+      // Format ONLY from diagnostics, not from error.message
+      console.error('');
+      console.error(`✗ Strict mode: ${e.count} unresolved reference(s) found during ENRICHMENT.`);
+      console.error('');
+      console.error(reporter.formatStrict(e.diagnostics, {
+        verbose: options.verbose,
+        suppressedCount: e.suppressedCount,  // REG-332
+      }));
+      console.error('');
+      console.error('Run without --strict for graceful degradation, or fix the underlying issues.');
+    } else {
+      // Generic error handling (non-strict)
+      const error = e instanceof Error ? e : new Error(String(e));
+      console.error('');
+      console.error(`✗ Analysis failed: ${error.message}`);
+      console.error('');
+      console.error('→ Run with --debug for detailed diagnostics');
+
+      if (diagnostics.count() > 0) {
+        console.error('');
+        console.error(reporter.report({ format: 'text', includeSummary: true }));
+      }
+    }
+
+    // Write diagnostics.log in debug mode even on failure
+    if (options.debug) {
+      const writer = new DiagnosticWriter();
+      await writer.write(diagnostics, grafemaDir);
+      console.error(`Diagnostics written to ${writer.getLogPath(grafemaDir)}`);
+    }
+
+    exitCode = 1;
+  } finally {
+    // Stop stats polling
+    if (statsInterval) {
+      clearInterval(statsInterval);
+      statsInterval = null;
+    }
+
+    if (backend.connected) {
+      await backend.close();
+    }
+
+    // Exit with appropriate code
+    // 0 = success, 1 = fatal, 2 = errors
+    exitWithCode(exitCode);
+  }
+}

package/src/commands/check.ts

@@ -137,7 +137,7 @@ Examples:
 
       // Check graph freshness
       const freshnessChecker = new GraphFreshnessChecker();
-      const freshness = await freshnessChecker.checkFreshness(backend);
+      const freshness = await freshnessChecker.checkFreshness(backend, projectPath);
 
       if (!freshness.isFresh) {
         if (options.failOnStale) {
@@ -292,7 +292,7 @@ async function runBuiltInValidator(
 
   // Check graph freshness
   const freshnessChecker = new GraphFreshnessChecker();
-  const freshness = await freshnessChecker.checkFreshness(backend);
+  const freshness = await freshnessChecker.checkFreshness(backend, resolvedPath);
 
   if (!freshness.isFresh) {
     if (options.failOnStale) {

package/src/commands/context.ts

@@ -0,0 +1,309 @@
+/**
+ * Context command — Show deep context for a graph node
+ *
+ * Displays the full graph neighborhood: source code + all incoming/outgoing edges
+ * with code context at each connected node's location.
+ *
+ * Works for ANY node type: FUNCTION, VARIABLE, MODULE, http:route, CALL, etc.
+ *
+ * Output is grep-friendly with stable prefixes:
+ *   -> outgoing edges
+ *   <- incoming edges
+ *   >  highlighted source lines
+ */
+
+import { Command } from 'commander';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import {
+  RFDBServerBackend,
+  buildNodeContext,
+  getNodeDisplayName,
+  formatEdgeMetadata,
+  STRUCTURAL_EDGE_TYPES,
+} from '@grafema/core';
+import type { NodeContext, EdgeGroup } from '@grafema/core';
+import type { BaseNodeRecord } from '@grafema/types';
+import { getCodePreview, formatCodePreview } from '../utils/codePreview.js';
+import { formatLocation } from '../utils/formatNode.js';
+import { exitWithError } from '../utils/errorFormatter.js';
+import { Spinner } from '../utils/spinner.js';
+
+interface ContextOptions {
+  project: string;
+  json?: boolean;
+  lines: string;
+  edgeType?: string;
+}
+
+/** Extended context with CLASS member expansion (REG-411) */
+interface ContextWithMembers extends NodeContext {
+  memberContexts?: NodeContext[];
+}
+
+export const contextCommand = new Command('context')
+  .description('Show deep context for a graph node: source code + graph neighborhood')
+  .argument('<semanticId>', 'Semantic ID of the node (exact match)')
+  .option('-p, --project <path>', 'Project path', '.')
+  .option('-j, --json', 'Output as JSON (full dump, no filtering)')
+  .option('-l, --lines <n>', 'Context lines around each code reference', '3')
+  .option(
+    '-e, --edge-type <type>',
+    `Filter edges by type (e.g., CALLS, ASSIGNED_FROM, DEPENDS_ON)
+
+Multiple types can be comma-separated: --edge-type CALLS,ASSIGNED_FROM
+
+Examples:
+  grafema context <id> --edge-type CALLS
+  grafema context <id> -e DEPENDS_ON,IMPORTS_FROM`
+  )
+  .addHelpText('after', `
+Output format (grep-friendly):
+  ->  outgoing edge (this node points to)
+  <-  incoming edge (points to this node)
+  >   highlighted source line
+
+Examples:
+  grafema context "src/app.js->global->FUNCTION->main"
+  grafema context "http:route#POST#/api/users" --edge-type ROUTES_TO,HANDLED_BY
+  grafema context <id> --json
+  grafema context <id> | grep "CALLS"
+  grafema context <id> | grep "<-"
+`)
+  .action(async (semanticId: string, options: ContextOptions) => {
+    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();
+
+    const spinner = new Spinner('Loading context...');
+    spinner.start();
+
+    try {
+      const contextLines = parseInt(options.lines, 10);
+      const edgeTypeFilter = options.edgeType
+        ? new Set(options.edgeType.split(',').map(t => t.trim().toUpperCase()))
+        : null;
+
+      // 1. Look up node by exact semantic ID
+      const node = await backend.getNode(semanticId);
+      if (!node) {
+        spinner.stop();
+        exitWithError(`Node not found: "${semanticId}"`, [
+          'Use: grafema query "<name>" to find the correct semantic ID',
+        ]);
+      }
+
+      // 2. Build context (with CLASS member expansion)
+      const ctx = await buildContextWithMembers(backend, node, { contextLines, edgeTypeFilter });
+
+      spinner.stop();
+
+      // 3. Output
+      if (options.json) {
+        console.log(JSON.stringify(ctx, null, 2));
+      } else {
+        printContext(ctx, projectPath, contextLines);
+      }
+    } finally {
+      spinner.stop();
+      await backend.close();
+    }
+  });
+
+/**
+ * Build context with CLASS member expansion (REG-411)
+ */
+async function buildContextWithMembers(
+  backend: RFDBServerBackend,
+  node: BaseNodeRecord,
+  options: { contextLines: number; edgeTypeFilter: Set<string> | null },
+): Promise<ContextWithMembers> {
+  const ctx = await buildNodeContext(backend, node, options);
+
+  let memberContexts: NodeContext[] | undefined;
+  if (node.type === 'CLASS') {
+    const outEdges = await backend.getOutgoingEdges(node.id);
+    const containsEdges = outEdges.filter(e => e.type === 'CONTAINS');
+    const members: NodeContext[] = [];
+    for (const edge of containsEdges) {
+      const memberNode = await backend.getNode(edge.dst);
+      if (memberNode && (memberNode.type === 'FUNCTION' || memberNode.type === 'METHOD')) {
+        const memberCtx = await buildNodeContext(backend, memberNode, options);
+        members.push(memberCtx);
+      }
+    }
+    members.sort((a, b) => {
+      const lineA = (a.node.line as number | undefined) ?? 0;
+      const lineB = (b.node.line as number | undefined) ?? 0;
+      return lineA - lineB;
+    });
+    if (members.length > 0) {
+      memberContexts = members;
+    }
+  }
+
+  return { ...ctx, memberContexts };
+}
+
+/**
+ * Print context to stdout in grep-friendly format
+ */
+function printContext(ctx: ContextWithMembers, projectPath: string, contextLines: number): void {
+  const { node, source, outgoing, incoming } = ctx;
+
+  // Node header
+  const displayName = getNodeDisplayName(node);
+  console.log(`[${node.type}] ${displayName}`);
+  console.log(`  ID: ${node.id}`);
+
+  const loc = formatLocation(node.file, node.line as number | undefined, projectPath);
+  if (loc) {
+    console.log(`  Location: ${loc}`);
+  }
+
+  // Source code
+  if (source) {
+    console.log('');
+    console.log(`  Source (lines ${source.startLine}-${source.endLine}):`);
+    const formatted = formatCodePreview(
+      { lines: source.lines, startLine: source.startLine, endLine: source.endLine },
+      node.line as number | undefined,
+    );
+    for (const line of formatted) {
+      console.log(`    ${line}`);
+    }
+  }
+
+  // Outgoing edges
+  if (outgoing.length > 0) {
+    console.log('');
+    console.log('  Outgoing edges:');
+    for (const group of outgoing) {
+      printEdgeGroup(group, '->', projectPath, contextLines);
+    }
+  }
+
+  // Incoming edges
+  if (incoming.length > 0) {
+    console.log('');
+    console.log('  Incoming edges:');
+    for (const group of incoming) {
+      printEdgeGroup(group, '<-', projectPath, contextLines);
+    }
+  }
+
+  // Member methods (CLASS nodes)
+  if (ctx.memberContexts && ctx.memberContexts.length > 0) {
+    console.log('');
+    console.log(`  Methods (${ctx.memberContexts.length}):`);
+    for (const memberCtx of ctx.memberContexts) {
+      console.log('');
+      console.log(`  ── [${memberCtx.node.type}] ${getNodeDisplayName(memberCtx.node)}`);
+      const memberLoc = formatLocation(
+        memberCtx.node.file,
+        memberCtx.node.line as number | undefined,
+        projectPath,
+      );
+      if (memberLoc) {
+        console.log(`     Location: ${memberLoc}`);
+      }
+
+      // Method source code
+      if (memberCtx.source) {
+        console.log('');
+        console.log(`     Source (lines ${memberCtx.source.startLine}-${memberCtx.source.endLine}):`);
+        const formatted = formatCodePreview(
+          {
+            lines: memberCtx.source.lines,
+            startLine: memberCtx.source.startLine,
+            endLine: memberCtx.source.endLine,
+          },
+          memberCtx.node.line as number | undefined,
+        );
+        for (const line of formatted) {
+          console.log(`       ${line}`);
+        }
+      }
+
+      // Method edges (non-structural only, to avoid clutter)
+      const methodOutgoing = memberCtx.outgoing.filter(g => !STRUCTURAL_EDGE_TYPES.has(g.edgeType));
+      const methodIncoming = memberCtx.incoming.filter(g => !STRUCTURAL_EDGE_TYPES.has(g.edgeType));
+
+      if (methodOutgoing.length > 0) {
+        console.log('');
+        console.log('     Outgoing edges:');
+        for (const group of methodOutgoing) {
+          printEdgeGroup(group, '->', projectPath, contextLines, '       ');
+        }
+      }
+      if (methodIncoming.length > 0) {
+        console.log('');
+        console.log('     Incoming edges:');
+        for (const group of methodIncoming) {
+          printEdgeGroup(group, '<-', projectPath, contextLines, '       ');
+        }
+      }
+    }
+  }
+
+  // Summary if no edges and no members
+  if (outgoing.length === 0 && incoming.length === 0 && !ctx.memberContexts?.length) {
+    console.log('');
+    console.log('  No edges found.');
+  }
+}
+
+/**
+ * Print a group of edges with the same type
+ */
+function printEdgeGroup(
+  group: EdgeGroup,
+  direction: '->' | '<-',
+  projectPath: string,
+  contextLines: number,
+  indent = '    ',
+): void {
+  const isStructural = STRUCTURAL_EDGE_TYPES.has(group.edgeType);
+
+  console.log(`${indent}${group.edgeType} (${group.edges.length}):`);
+
+  for (const { edge, node } of group.edges) {
+    if (!node) {
+      const danglingId = direction === '->' ? edge.dst : edge.src;
+      console.log(`${indent}  ${direction} [dangling] ${danglingId}`);
+      continue;
+    }
+
+    const displayName = getNodeDisplayName(node);
+    const loc = formatLocation(node.file, node.line as number | undefined, projectPath);
+    const locStr = loc ? `  (${loc})` : '';
+
+    // Edge metadata inline (if present and useful)
+    const metaStr = formatEdgeMetadata(edge);
+
+    console.log(`${indent}  ${direction} [${node.type}] ${displayName}${locStr}${metaStr}`);
+
+    // Code context for non-structural edges
+    if (!isStructural && node.file && node.line && contextLines > 0) {
+      const preview = getCodePreview({
+        file: node.file,
+        line: node.line as number,
+        contextBefore: Math.min(contextLines, 2),
+        contextAfter: Math.min(contextLines, 2),
+      });
+      if (preview) {
+        const formatted = formatCodePreview(preview, node.line as number);
+        for (const line of formatted) {
+          console.log(`${indent}       ${line}`);
+        }
+      }
+    }
+  }
+}

package/src/commands/doctor/checks.ts

@@ -527,7 +527,7 @@ export async function checkFreshness(
   try {
     await backend.connect();
     const freshnessChecker = new GraphFreshnessChecker();
-    const result = await freshnessChecker.checkFreshness(backend);
+    const result = await freshnessChecker.checkFreshness(backend, projectPath);
     await backend.close();
 
     if (result.isFresh) {

package/src/commands/explain.ts

@@ -15,6 +15,7 @@
 import { Command } from 'commander';
 import { resolve, join, relative, normalize } from 'path';
 import { existsSync, realpathSync } from 'fs';
+import { toRelativeDisplay } from '../utils/pathUtils.js';
 import { RFDBServerBackend, FileExplainer, type EnhancedNode } from '@grafema/core';
 import { exitWithError } from '../utils/errorFormatter.js';
 
@@ -85,8 +86,8 @@ If a file shows NOT_ANALYZED:
 
     try {
       const explainer = new FileExplainer(backend);
-      // Query with absolute path since graph stores absolute paths
-      const result = await explainer.explain(absoluteFilePath);
+      // Query with relative path since MODULE nodes store relative file paths
+      const result = await explainer.explain(relativeFilePath);
 
       // Override file in result for display purposes (show relative path)
       result.file = relativeFilePath;
@@ -166,7 +167,7 @@ function displayNode(node: EnhancedNode, type: string, projectPath: string): voi
 
   // Line 3: Location
   if (node.file) {
-    const relPath = relative(projectPath, node.file);
+    const relPath = toRelativeDisplay(node.file, projectPath);
     const loc = node.line ? `${relPath}:${node.line}` : relPath;
     console.log(`  Location: ${loc}`);
   }

package/src/commands/explore.tsx

@@ -9,7 +9,8 @@
  */
 
 import { Command } from 'commander';
-import { resolve, join, relative } from 'path';
+import { resolve, join } from 'path';
+import { toRelativeDisplay } from '../utils/pathUtils.js';
 import { existsSync } from 'fs';
 import { execSync } from 'child_process';
 import React, { useState, useEffect } from 'react';
@@ -234,6 +235,7 @@ function Explorer({ backend, startNode, projectPath }: ExplorerProps) {
           const preview = getCodePreview({
             file: state.currentNode.file,
             line: state.currentNode.line,
+            projectPath,
           });
           if (preview) {
             const formatted = formatCodePreview(preview, state.currentNode.line);
@@ -421,7 +423,7 @@ function Explorer({ backend, startNode, projectPath }: ExplorerProps) {
 
   const formatLoc = (node: NodeInfo) => {
     if (!node.file) return '';
-    const rel = relative(projectPath, node.file);
+    const rel = toRelativeDisplay(node.file, projectPath);
     return node.line ? `${rel}:${node.line}` : rel;
   };
 
@@ -1040,7 +1042,7 @@ function outputResults(
     // 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(`File: ${toRelativeDisplay(target.file, projectPath)}${target.line ? `:${target.line}` : ''}`);
       console.log('');
     }
 
@@ -1048,7 +1050,7 @@ function outputResults(
       console.log(`  (no ${mode} found)`);
     } else {
       for (const node of nodes) {
-        const loc = relative(projectPath, node.file);
+        const loc = toRelativeDisplay(node.file, projectPath);
         console.log(`  ${node.type} ${node.name} (${loc}${node.line ? `:${node.line}` : ''})`);
       }
     }
@@ -1063,7 +1065,7 @@ function formatNodeForJson(node: NodeInfo, projectPath: string): object {
     id: node.id,
     type: node.type,
     name: node.name,
-    file: relative(projectPath, node.file),
+    file: toRelativeDisplay(node.file, projectPath),
     line: node.line,
     async: node.async,
     exported: node.exported,