@grafema/cli 0.1.1-alpha → 0.2.1-beta

package/src/commands/types.ts

@@ -0,0 +1,94 @@
+/**
+ * Types command - List all node types in the graph
+ *
+ * Shows all node types present in the analyzed codebase with counts.
+ * Useful for:
+ * - Discovering what types exist (standard and custom)
+ * - Understanding graph composition
+ * - Finding types to use with --type flag
+ */
+
+import { Command } from 'commander';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import { RFDBServerBackend } from '@grafema/core';
+import { exitWithError } from '../utils/errorFormatter.js';
+
+interface TypesOptions {
+  project: string;
+  json?: boolean;
+  sort?: 'count' | 'name';
+}
+
+export const typesCommand = new Command('types')
+  .description('List all node types in the graph')
+  .option('-p, --project <path>', 'Project path', '.')
+  .option('-j, --json', 'Output as JSON')
+  .option('-s, --sort <by>', 'Sort by: count (default) or name', 'count')
+  .addHelpText('after', `
+Examples:
+  grafema types                  List all node types with counts
+  grafema types --json           Output as JSON for scripting
+  grafema types --sort name      Sort alphabetically by type name
+  grafema types -s count         Sort by count (default, descending)
+
+Use with query --type:
+  grafema types                  # See available types
+  grafema query --type jsx:component "Button"   # Query specific type
+`)
+  .action(async (options: TypesOptions) => {
+    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 nodeCounts = await backend.countNodesByType();
+      const entries = Object.entries(nodeCounts);
+
+      if (entries.length === 0) {
+        console.log('No nodes in graph. Run: grafema analyze');
+        return;
+      }
+
+      // Sort entries
+      const sortedEntries = options.sort === 'name'
+        ? entries.sort((a, b) => a[0].localeCompare(b[0]))
+        : entries.sort((a, b) => b[1] - a[1]); // count descending
+
+      if (options.json) {
+        const result = {
+          types: sortedEntries.map(([type, count]) => ({ type, count })),
+          totalTypes: sortedEntries.length,
+          totalNodes: sortedEntries.reduce((sum, [, count]) => sum + count, 0),
+        };
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log('Node Types in Graph:');
+        console.log('');
+
+        // Calculate max type length for alignment
+        const maxTypeLen = Math.max(...sortedEntries.map(([type]) => type.length));
+
+        for (const [type, count] of sortedEntries) {
+          const paddedType = type.padEnd(maxTypeLen);
+          const formattedCount = count.toLocaleString();
+          console.log(`  ${paddedType}  ${formattedCount}`);
+        }
+
+        console.log('');
+        const totalNodes = sortedEntries.reduce((sum, [, count]) => sum + count, 0);
+        console.log(`Total: ${sortedEntries.length} types, ${totalNodes.toLocaleString()} nodes`);
+        console.log('');
+        console.log('Tip: Use grafema query --type <type> "pattern" to search within a type');
+      }
+    } finally {
+      await backend.close();
+    }
+  });

package/src/utils/formatNode.ts

@@ -33,6 +33,45 @@ export interface DisplayableNode {
   file: string;
   /** Line number (optional) */
   line?: number;
+  /** HTTP method (for http:route, http:request) */
+  method?: string;
+  /** Path or URL (for http:route, http:request) */
+  path?: string;
+  /** URL (for http:request) */
+  url?: string;
+}
+
+/**
+ * Get the display name for a node based on its type.
+ *
+ * HTTP nodes use method + path/url instead of name.
+ * Other nodes use their name field.
+ */
+export function getNodeDisplayName(node: DisplayableNode): string {
+  switch (node.type) {
+    case 'http:route':
+      // Express routes: "GET /users"
+      if (node.method && node.path) {
+        return `${node.method} ${node.path}`;
+      }
+      break;
+    case 'http:request':
+      // Fetch/axios requests: "POST /api/data"
+      if (node.method && node.url) {
+        return `${node.method} ${node.url}`;
+      }
+      break;
+  }
+  // Default: use name, but guard against JSON metadata corruption
+  if (node.name && !node.name.startsWith('{')) {
+    return node.name;
+  }
+  // Fallback: extract name from semantic ID if possible
+  const parts = node.id.split('#');
+  if (parts.length > 1) {
+    return parts[1]; // Usually contains the key identifier
+  }
+  return node.id;
 }
 
 /**
@@ -47,8 +86,9 @@ export function formatNodeDisplay(node: DisplayableNode, options: FormatNodeOpti
   const { projectPath, showLocation = true, indent = '' } = options;
   const lines: string[] = [];
 
-  // Line 1: [TYPE] name
-  lines.push(`${indent}[${node.type}] ${node.name}`);
+  // Line 1: [TYPE] display name (type-specific)
+  const displayName = getNodeDisplayName(node);
+  lines.push(`${indent}[${node.type}] ${displayName}`);
 
   // Line 2: ID (semantic ID)
   lines.push(`${indent}  ID: ${node.id}`);