coderaph 0.1.0 → 0.3.0

package/dist/cli/analyzer.d.ts

@@ -1,9 +1,16 @@
 import { Project, SourceFile } from 'ts-morph';
 export interface AnalyzerOptions {
     projectPath: string;
+    tsConfigPath?: string;
     include?: string[];
     exclude?: string[];
+    prefix?: string;
 }
+/**
+ * Reads the `name` field from package.json in the given directory.
+ * Returns undefined if the file doesn't exist or can't be parsed.
+ */
+export declare function readPackageName(projectPath: string): string | undefined;
 /**
  * Loads a TypeScript project and returns filtered source files.
  */

package/dist/cli/analyzer.js

@@ -1,6 +1,21 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { Project } from 'ts-morph';
+/**
+ * Reads the `name` field from package.json in the given directory.
+ * Returns undefined if the file doesn't exist or can't be parsed.
+ */
+export function readPackageName(projectPath) {
+    try {
+        const pkgPath = path.resolve(projectPath, 'package.json');
+        const content = fs.readFileSync(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        return typeof pkg.name === 'string' ? pkg.name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Simple glob matcher that supports `*` as a wildcard for any characters.
  * If the pattern contains no `*`, it falls back to substring matching.
@@ -16,13 +31,55 @@ function matchGlob(filePath, pattern) {
     const regex = new RegExp(`^${escaped}$`);
     return regex.test(filePath);
 }
+const TSCONFIG_CANDIDATES = [
+    'tsconfig.json',
+    'tsconfig.build.json',
+    'tsconfig.base.json',
+    'tsconfig.app.json',
+];
+/**
+ * Finds a tsconfig file in the given directory.
+ * Checks common tsconfig filenames, then searches subdirectories (1 level deep).
+ */
+function findTsConfig(projectPath) {
+    // Check common names in project root
+    for (const candidate of TSCONFIG_CANDIDATES) {
+        const fullPath = path.resolve(projectPath, candidate);
+        if (fs.existsSync(fullPath))
+            return fullPath;
+    }
+    // Search one level of subdirectories (for monorepos: packages/*, apps/*)
+    const entries = fs.readdirSync(projectPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === 'node_modules' || entry.name.startsWith('.'))
+            continue;
+        const subTsConfig = path.resolve(projectPath, entry.name, 'tsconfig.json');
+        if (fs.existsSync(subTsConfig))
+            return subTsConfig;
+    }
+    return null;
+}
 /**
  * Loads a TypeScript project and returns filtered source files.
  */
 export function loadProject(options) {
-    const tsConfigFilePath = path.resolve(options.projectPath, 'tsconfig.json');
-    if (!fs.existsSync(tsConfigFilePath)) {
-        throw new Error(`tsconfig.json not found at ${tsConfigFilePath}. Please ensure the project path is correct.`);
+    let tsConfigFilePath;
+    if (options.tsConfigPath) {
+        tsConfigFilePath = path.resolve(options.projectPath, options.tsConfigPath);
+        if (!fs.existsSync(tsConfigFilePath)) {
+            throw new Error(`tsconfig not found at ${tsConfigFilePath}. Please check the --tsconfig path.`);
+        }
+    }
+    else {
+        const found = findTsConfig(options.projectPath);
+        if (!found) {
+            throw new Error(`No tsconfig.json found in ${options.projectPath} or its subdirectories. ` +
+                `Use --tsconfig to specify the path (e.g. --tsconfig packages/app/tsconfig.json).`);
+        }
+        tsConfigFilePath = found;
+        if (path.basename(tsConfigFilePath) !== 'tsconfig.json' || path.dirname(tsConfigFilePath) !== options.projectPath) {
+            console.log(`Using tsconfig: ${path.relative(options.projectPath, tsConfigFilePath)}`);
+        }
     }
     const project = new Project({ tsConfigFilePath });
     let sourceFiles = project.getSourceFiles().filter((file) => {
@@ -50,13 +107,12 @@ export function loadProject(options) {
             return !excludePatterns.some((pattern) => matchGlob(relativePath, pattern));
         });
     }
-    // Check for syntax errors and skip problematic files
+    // Skip files with actual syntax errors (not type errors — those are fine for graph analysis)
     sourceFiles = sourceFiles.filter((file) => {
-        const diagnostics = file.getPreEmitDiagnostics();
-        const syntaxErrors = diagnostics.filter((d) => d.getCategory() === 1 // DiagnosticCategory.Error
+        const syntaxDiagnostics = file.getPreEmitDiagnostics().filter((d) => d.getCode() >= 1000 && d.getCode() < 2000 // TS1xxx = syntax errors only
         );
-        if (syntaxErrors.length > 0) {
-            console.warn(`Warning: Skipping ${path.relative(options.projectPath, file.getFilePath())} due to ${syntaxErrors.length} syntax error(s)`);
+        if (syntaxDiagnostics.length > 0) {
+            console.warn(`Warning: Skipping ${path.relative(options.projectPath, file.getFilePath())} due to ${syntaxDiagnostics.length} syntax error(s)`);
             return false;
         }
         return true;

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { loadProject } from './analyzer.js';
+import { loadProject, readPackageName } from './analyzer.js';
 import { buildFileGraph } from './file-graph.js';
 import { buildSymbolGraph } from './symbol-graph.js';
 import fs from 'node:fs';
@@ -9,61 +9,130 @@ const program = new Command();
 program
     .name('coderaph')
     .description('TypeScript dependency graph 3D visualizer')
-    .version('0.1.0');
+    .version('0.3.0');
 program
     .command('analyze <project-path>')
     .description('Analyze TypeScript project and generate dependency graph JSON')
     .option('-o, --output <path>', 'Output JSON file path', 'coderaph-output.json')
+    .option('--tsconfig <path>', 'Path to tsconfig.json (relative to project path)')
     .option('--include <patterns...>', 'Include glob patterns')
     .option('--exclude <patterns...>', 'Exclude glob patterns')
+    .option('--prefix <path>', 'Prefix to prepend to all file IDs (e.g., "packages/core")')
     .action((projectPath, options) => {
     try {
         const resolvedPath = path.resolve(projectPath);
         console.log(`Analyzing ${resolvedPath}...`);
-        const { sourceFiles } = loadProject({
-            projectPath: resolvedPath,
-            include: options.include,
-            exclude: options.exclude,
-        });
-        console.log(`Found ${sourceFiles.length} source files`);
-        if (sourceFiles.length === 0) {
-            console.warn('No source files to analyze');
-        }
-        const { files, edges: fileEdges } = buildFileGraph(sourceFiles, resolvedPath);
-        const { symbols, edges: symbolEdges } = buildSymbolGraph(sourceFiles, resolvedPath);
-        // Populate FileNode.symbols arrays
-        const fileSymbolMap = new Map();
-        for (const symbol of symbols) {
-            const existing = fileSymbolMap.get(symbol.fileId) || [];
-            existing.push(symbol.id);
-            fileSymbolMap.set(symbol.fileId, existing);
-        }
-        for (const file of files) {
-            file.symbols = fileSymbolMap.get(file.id) || [];
-        }
-        const output = {
-            version: 1,
-            files,
-            symbols,
-            fileEdges,
-            symbolEdges,
-        };
+        const output = runAnalyze(resolvedPath, options);
         const outputPath = path.resolve(options.output);
         fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
         console.log(`Output written to ${outputPath}`);
-        console.log(`Files: ${files.length}, Symbols: ${symbols.length}, File edges: ${fileEdges.length}, Symbol edges: ${symbolEdges.length}`);
+        console.log(`Files: ${output.files.length}, Symbols: ${output.symbols.length}, File edges: ${output.fileEdges.length}, Symbol edges: ${output.symbolEdges.length}`);
     }
     catch (err) {
         console.error(`Error: ${err instanceof Error ? err.message : err}`);
         process.exit(1);
     }
 });
+/**
+ * Runs the analysis pipeline and returns a CoderaphOutput.
+ * Extracted so it can be used by both the `analyze` and `view --analyze` commands.
+ */
+function runAnalyze(resolvedPath, options) {
+    const { sourceFiles } = loadProject({
+        projectPath: resolvedPath,
+        tsConfigPath: options.tsconfig,
+        include: options.include,
+        exclude: options.exclude,
+        prefix: options.prefix,
+    });
+    console.log(`Found ${sourceFiles.length} source files`);
+    if (sourceFiles.length === 0) {
+        console.warn('No source files to analyze');
+    }
+    const { files, edges: fileEdges } = buildFileGraph(sourceFiles, resolvedPath);
+    const { symbols, edges: symbolEdges } = buildSymbolGraph(sourceFiles, resolvedPath);
+    // Populate FileNode.symbols arrays
+    const fileSymbolMap = new Map();
+    for (const symbol of symbols) {
+        const existing = fileSymbolMap.get(symbol.fileId) || [];
+        existing.push(symbol.id);
+        fileSymbolMap.set(symbol.fileId, existing);
+    }
+    for (const file of files) {
+        file.symbols = fileSymbolMap.get(file.id) || [];
+    }
+    const packageName = readPackageName(resolvedPath);
+    const prefix = options.prefix;
+    // Apply prefix to all file IDs if provided
+    if (prefix) {
+        const addPrefix = (id) => `${prefix}/${id}`;
+        for (const file of files) {
+            file.id = addPrefix(file.id);
+            file.symbols = file.symbols.map(addPrefix);
+        }
+        for (const symbol of symbols) {
+            symbol.id = addPrefix(symbol.id);
+            symbol.fileId = addPrefix(symbol.fileId);
+        }
+        for (const edge of fileEdges) {
+            edge.source = addPrefix(edge.source);
+            edge.target = addPrefix(edge.target);
+        }
+        for (const edge of symbolEdges) {
+            edge.source = addPrefix(edge.source);
+            edge.target = addPrefix(edge.target);
+        }
+    }
+    const useV2 = !!(prefix || packageName);
+    const output = {
+        version: useV2 ? 2 : 1,
+        ...(packageName ? { name: packageName } : {}),
+        ...(prefix ? { prefix } : {}),
+        files,
+        symbols,
+        fileEdges,
+        symbolEdges,
+    };
+    return output;
+}
 program
-    .command('view <json-path>')
+    .command('view [json-path...]')
     .description('Start web viewer for dependency graph')
     .option('-p, --port <number>', 'Server port', '3000')
-    .action(async (jsonPath, options) => {
+    .option('--analyze <project-path>', 'Run analysis in-memory and start viewer')
+    .option('--tsconfig <path>', 'Path to tsconfig.json (used with --analyze)')
+    .option('--include <patterns...>', 'Include glob patterns (used with --analyze)')
+    .option('--exclude <patterns...>', 'Exclude glob patterns (used with --analyze)')
+    .option('-o, --output <path>', 'Save analysis result to file (used with --analyze)')
+    .option('--prefix <path>', 'Prefix for file IDs (used with --analyze)')
+    .action(async (jsonPaths, options) => {
     const { startServer } = await import('./server.js');
-    startServer(path.resolve(jsonPath), parseInt(options.port, 10));
+    const port = parseInt(options.port, 10);
+    if (options.analyze) {
+        // Run analysis in-memory
+        const resolvedPath = path.resolve(options.analyze);
+        console.log(`Analyzing ${resolvedPath}...`);
+        const output = runAnalyze(resolvedPath, {
+            tsconfig: options.tsconfig,
+            include: options.include,
+            exclude: options.exclude,
+            prefix: options.prefix,
+        });
+        // Optionally save to file
+        if (options.output) {
+            const outputPath = path.resolve(options.output);
+            fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
+            console.log(`Output written to ${outputPath}`);
+        }
+        startServer(output, port);
+    }
+    else if (jsonPaths && jsonPaths.length > 0) {
+        const resolvedPaths = jsonPaths.map((p) => path.resolve(p));
+        startServer(resolvedPaths, port);
+    }
+    else {
+        console.error('Error: provide either JSON file path(s) or --analyze <project-path>');
+        process.exit(1);
+    }
 });
 program.parse();

package/dist/cli/server.d.ts

@@ -1 +1,2 @@
-export declare function startServer(jsonPath: string, port: number): void;
+import type { CoderaphOutput } from '../types/graph.js';
+export declare function startServer(source: string[] | CoderaphOutput, port: number): void;

package/dist/cli/server.js

@@ -8,25 +8,109 @@ const MIME_TYPES = {
     '.js': 'application/javascript',
     '.css': 'text/css',
 };
-export function startServer(jsonPath, port) {
-    const absoluteJsonPath = path.resolve(jsonPath);
-    if (!fs.existsSync(absoluteJsonPath)) {
-        console.error(`Error: file not found — ${absoluteJsonPath}`);
-        process.exit(1);
+/**
+ * Reads multiple JSON files and merges them into a single CoderaphOutput.
+ * Cross-package edges are inferred by suffix matching of file IDs across packages.
+ */
+function mergeJsonFiles(jsonPaths) {
+    const outputs = jsonPaths.map((p) => {
+        const absolutePath = path.resolve(p);
+        if (!fs.existsSync(absolutePath)) {
+            console.error(`Error: file not found — ${absolutePath}`);
+            process.exit(1);
+        }
+        return JSON.parse(fs.readFileSync(absolutePath, 'utf-8'));
+    });
+    if (outputs.length === 1) {
+        return outputs[0];
+    }
+    const merged = {
+        version: 2,
+        files: [],
+        symbols: [],
+        fileEdges: [],
+        symbolEdges: [],
+    };
+    // Build a map of file ID suffix -> full file ID for cross-package edge inference
+    // Key: filename suffix (e.g., "src/utils/helper.ts"), Value: array of full IDs from different packages
+    const fileIdsByPackage = new Map();
+    const allFileIds = new Set();
+    for (let i = 0; i < outputs.length; i++) {
+        const output = outputs[i];
+        merged.files.push(...output.files);
+        merged.symbols.push(...output.symbols);
+        merged.fileEdges.push(...output.fileEdges);
+        merged.symbolEdges.push(...output.symbolEdges);
+        const ids = new Set(output.files.map((f) => f.id));
+        fileIdsByPackage.set(i, ids);
+        for (const id of ids) {
+            allFileIds.add(id);
+        }
+    }
+    // Cross-package edge inference:
+    // For each edge target in each package, if the target doesn't exist in the same package's files
+    // but matches a file ID in another package by suffix, add a cross-package edge.
+    for (let i = 0; i < outputs.length; i++) {
+        const pkgFileIds = fileIdsByPackage.get(i);
+        const existingEdgeTargets = new Set(outputs[i].fileEdges.map((e) => `${e.source}->${e.target}`));
+        for (const edge of outputs[i].fileEdges) {
+            // If the target is not in any known file, try suffix matching
+            if (!allFileIds.has(edge.target)) {
+                for (const [j, otherIds] of fileIdsByPackage) {
+                    if (i === j)
+                        continue;
+                    for (const otherId of otherIds) {
+                        if (otherId.endsWith(edge.target) || edge.target.endsWith(otherId)) {
+                            const edgeKey = `${edge.source}->${otherId}`;
+                            if (!existingEdgeTargets.has(edgeKey)) {
+                                merged.fileEdges.push({ source: edge.source, target: otherId });
+                                existingEdgeTargets.add(edgeKey);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
+    return merged;
+}
+export function startServer(source, port) {
     const webDir = fileURLToPath(new URL('../../src/web/', import.meta.url));
+    // Resolve the graph data
+    let graphData = null;
+    let jsonPaths = null;
+    if (Array.isArray(source) && source.length > 0 && typeof source[0] === 'string') {
+        jsonPaths = source;
+        // Validate files exist upfront
+        for (const p of jsonPaths) {
+            const absolutePath = path.resolve(p);
+            if (!fs.existsSync(absolutePath)) {
+                console.error(`Error: file not found — ${absolutePath}`);
+                process.exit(1);
+            }
+        }
+    }
+    else {
+        graphData = source;
+    }
     const server = http.createServer((req, res) => {
         const url = req.url ?? '/';
         if (req.method === 'GET' && url === '/api/graph') {
-            fs.readFile(absoluteJsonPath, 'utf-8', (err, data) => {
-                if (err) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Failed to read graph file' }));
-                    return;
+            try {
+                let data;
+                if (graphData) {
+                    data = graphData;
+                }
+                else {
+                    data = mergeJsonFiles(jsonPaths);
                 }
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(data);
-            });
+                res.end(JSON.stringify(data));
+            }
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Failed to read graph file' }));
+            }
             return;
         }
         // Serve static files from web directory

package/dist/types/graph.d.ts

@@ -14,7 +14,9 @@ export interface Edge {
     target: string;
 }
 export interface CoderaphOutput {
-    version: 1;
+    version: 1 | 2;
+    name?: string;
+    prefix?: string;
     files: FileNode[];
     symbols: SymbolNode[];
     fileEdges: Edge[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderaph",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "TypeScript dependency graph 3D visualizer",
   "type": "module",
   "bin": {

package/src/web/app.js

@@ -579,9 +579,35 @@ function matchGroupQuery(query, node) {
   return name.includes(q) || id.includes(q) || file.includes(q);
 }
 
+function nodeMatchesSubstring(node, val) {
+  const name = (node.name || '').toLowerCase();
+  const id = node.id.toLowerCase();
+  const file = (node.fileId || '').toLowerCase();
+  return name.includes(val) || id.includes(val) || file.includes(val);
+}
+
 function computeGroupNodeIds(query) {
   if (!graphData || !query.trim()) return [];
+  const q = query.trim().toLowerCase();
   const nodes = currentMode === 'file' ? graphData.files : graphData.symbols;
+  const edges = currentMode === 'file' ? graphData.fileEdges : graphData.symbolEdges;
+
+  // deps:X — nodes that import/depend on X (edges where target matches X)
+  if (q.startsWith('deps:')) {
+    const val = q.slice(5);
+    if (!val) return [];
+    const targetIds = new Set(nodes.filter(n => nodeMatchesSubstring(n, val)).map(n => n.id));
+    return edges.filter(e => targetIds.has(e.target)).map(e => e.source).filter((v, i, a) => a.indexOf(v) === i);
+  }
+
+  // rdeps:X — nodes that X depends on (edges where source matches X)
+  if (q.startsWith('rdeps:')) {
+    const val = q.slice(6);
+    if (!val) return [];
+    const sourceIds = new Set(nodes.filter(n => nodeMatchesSubstring(n, val)).map(n => n.id));
+    return edges.filter(e => sourceIds.has(e.source)).map(e => e.target).filter((v, i, a) => a.indexOf(v) === i);
+  }
+
   const ids = [];
   for (const node of nodes) {
     if (matchGroupQuery(query, node)) ids.push(node.id);

package/src/web/controls.js

@@ -568,7 +568,7 @@ function createGroupRow(query, colorNum) {
   const input = document.createElement('input');
   input.type = 'text';
   input.className = 'group-query';
-  input.placeholder = '검색어 입력... (path: file: kind:)';
+  input.placeholder = '검색어 입력... (path: file: kind: deps: rdeps:)';
   input.value = query || '';
 
   const colorInput = document.createElement('input');
@@ -615,6 +615,10 @@ function createGroupRow(query, colorNum) {
         el.value = 'file:' + (item.fileId || item.id).split('/').pop();
       } else if (val.startsWith('kind:')) {
         el.value = 'kind:' + (item.kind || 'file');
+      } else if (val.startsWith('deps:')) {
+        el.value = 'deps:' + (item.name || item.id.split('/').pop());
+      } else if (val.startsWith('rdeps:')) {
+        el.value = 'rdeps:' + (item.name || item.id.split('/').pop());
       } else {
         el.value = item.name || item.id.split('/').pop();
       }
@@ -656,6 +660,27 @@ function getGroupQueryCandidates(rawQuery) {
     for (const item of items) kinds.add(item.kind || 'file');
     return [...kinds].filter(k => k.includes(val)).map(k => ({ id: k, name: k, kind: k }));
   }
+  // For deps:/rdeps: prefix, return matching nodes as candidates
+  if (q.startsWith('deps:')) {
+    const val = q.slice(5);
+    if (!val) return items;
+    return items.filter(n => {
+      const name = (n.name || '').toLowerCase();
+      const id = n.id.toLowerCase();
+      const file = (n.fileId || '').toLowerCase();
+      return name.includes(val) || id.includes(val) || file.includes(val);
+    });
+  }
+  if (q.startsWith('rdeps:')) {
+    const val = q.slice(6);
+    if (!val) return items;
+    return items.filter(n => {
+      const name = (n.name || '').toLowerCase();
+      const id = n.id.toLowerCase();
+      const file = (n.fileId || '').toLowerCase();
+      return name.includes(val) || id.includes(val) || file.includes(val);
+    });
+  }
   return items;
 }
 
@@ -669,6 +694,8 @@ function showGroupHint(inputEl) {
     { prefix: 'path:', desc: '일치하는 파일 경로' },
     { prefix: 'file:', desc: '일치하는 파일 이름' },
     { prefix: 'kind:', desc: 'class, function, interface 등' },
+    { prefix: 'deps:', desc: '해당 노드를 import하는 노드' },
+    { prefix: 'rdeps:', desc: '해당 노드가 의존하는 노드' },
   ];
   for (const opt of options) {
     const item = document.createElement('div');