@rayburst/cli 0.2.0 → 0.2.1

package/dist/analysis/analyze-project.js

@@ -1,440 +0,0 @@
-import { Project, SyntaxKind, Node } from 'ts-morph';
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import crypto from 'crypto';
-/**
- * Analyze a TypeScript/React project and generate nodes/edges data
- * @param {string} projectPath - Absolute path to project root
- * @param {string} projectId - Project ID
- * @param {function} onLog - Callback for logging
- * @returns {Promise<AnalysisResult>} Analysis data with nodes and edges
- */
-export async function analyzeProject(projectPath, projectId, onLog) {
-    const logs = [];
-    const log = (message) => {
-        console.log(message);
-        logs.push(message);
-        // Call the callback if provided (for real-time streaming)
-        if (onLog) {
-            onLog(message);
-        }
-    };
-    log(`Analyzing project at: ${projectPath}`);
-    const gitHash = getGitHash(projectPath);
-    const gitInfo = getGitInfo(projectPath);
-    log(`  Git hash: ${gitHash}`);
-    log(`  Current branch: ${gitInfo.branch}`);
-    // Find tsconfig.json
-    const tsconfigPath = path.join(projectPath, 'tsconfig.json');
-    if (!fs.existsSync(tsconfigPath)) {
-        log(`  Warning: No tsconfig.json found, skipping TypeScript analysis`);
-        const emptyAnalysis = createEmptyAnalysis(projectPath, gitInfo);
-        emptyAnalysis.logs = logs;
-        return emptyAnalysis;
-    }
-    try {
-        // Initialize ts-morph project
-        const project = new Project({
-            tsConfigFilePath: tsconfigPath,
-        });
-        const nodes = [];
-        const edges = [];
-        const nodeMap = new Map();
-        const usedIds = new Set();
-        const idCounters = new Map();
-        // Track file positions for layout
-        let fileIndex = 0;
-        const filePositions = new Map();
-        // Get all source files (excluding node_modules, test files)
-        const sourceFiles = project.getSourceFiles()
-            .filter(sf => {
-            const filePath = sf.getFilePath();
-            return !filePath.includes('node_modules') &&
-                !filePath.includes('.test.') &&
-                !filePath.includes('.spec.') &&
-                (filePath.endsWith('.ts') || filePath.endsWith('.tsx'));
-        });
-        log(`  Analyzing ${sourceFiles.length} source files...`);
-        // Analyze each source file
-        for (let i = 0; i < sourceFiles.length; i++) {
-            const sourceFile = sourceFiles[i];
-            const filePath = sourceFile.getFilePath();
-            const relativePath = filePath.replace(projectPath + '/', '');
-            if (!filePositions.has(relativePath)) {
-                filePositions.set(relativePath, fileIndex++);
-            }
-            const baseX = (filePositions.get(relativePath) || 0) * 400;
-            let nodeY = 100;
-            // Extract React components
-            const components = extractComponents(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
-            nodeY += components * 150;
-            // Extract functions
-            const functions = extractFunctions(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
-            nodeY += functions * 150;
-            // Extract state declarations
-            const states = extractState(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
-            nodeY += states * 150;
-            // Yield to event loop every 10 files to allow SSE streaming
-            if (i % 10 === 0 && i > 0) {
-                await new Promise(resolve => setImmediate(resolve));
-            }
-        }
-        log(`  Extracted ${nodes.length} nodes`);
-        // Generate edges by analyzing relationships
-        for (const sourceFile of sourceFiles) {
-            generateEdges(sourceFile, nodeMap, edges);
-        }
-        log(`  Generated ${edges.length} edges`);
-        // Read package.json for project metadata
-        const packageJsonPath = path.join(projectPath, 'package.json');
-        let packageJson = { name: path.basename(projectPath) };
-        if (fs.existsSync(packageJsonPath)) {
-            packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        }
-        const branchId = gitInfo.branch.replace(/[^a-zA-Z0-9]/g, '-');
-        const projectMetadata = {
-            id: projectId || crypto.createHash('md5').update(projectPath).digest('hex').substring(0, 12),
-            title: packageJson.name || path.basename(projectPath),
-            subtitle: new Date().toLocaleDateString(),
-            value: `${nodes.length} nodes`,
-            trend: 0,
-            chartData: [30, 40, 35, 50, 45, 60, 55, 70],
-            chartColor: '#22c55e',
-        };
-        const branchMetadata = {
-            id: branchId,
-            name: gitInfo.branch,
-            lastCommit: gitInfo.lastCommit,
-            lastCommitDate: 'just now',
-            author: gitInfo.author,
-            status: 'active',
-            commitCount: gitInfo.commitCount,
-            pullRequests: 0,
-        };
-        const planData = {
-            nodes,
-            edges,
-        };
-        const result = {
-            project: projectMetadata,
-            branches: [branchMetadata],
-            planData: {
-                [branchId]: planData
-            },
-            analyzedAt: new Date().toISOString(),
-            logs,
-        };
-        return result;
-    }
-    catch (error) {
-        console.error(`  Error analyzing project:`, error.message);
-        log(`  Error: ${error.message}`);
-        const emptyAnalysis = createEmptyAnalysis(projectPath, gitInfo);
-        emptyAnalysis.logs = logs;
-        return emptyAnalysis;
-    }
-}
-function createEmptyAnalysis(projectPath, gitInfo) {
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    let packageJson = { name: path.basename(projectPath) };
-    if (fs.existsSync(packageJsonPath)) {
-        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-    }
-    const branchId = gitInfo.branch.replace(/[^a-zA-Z0-9]/g, '-');
-    return {
-        project: {
-            id: crypto.createHash('md5').update(projectPath).digest('hex').substring(0, 12),
-            title: packageJson.name || path.basename(projectPath),
-            subtitle: new Date().toLocaleDateString(),
-            value: '0 nodes',
-            trend: 0,
-            chartData: [],
-            chartColor: '#6b7280',
-        },
-        branches: [{
-                id: branchId,
-                name: gitInfo.branch,
-                lastCommit: gitInfo.lastCommit,
-                lastCommitDate: 'just now',
-                author: gitInfo.author,
-                status: 'active',
-                commitCount: gitInfo.commitCount,
-                pullRequests: 0,
-            }],
-        planData: {},
-        analyzedAt: new Date().toISOString(),
-    };
-}
-function getGitHash(projectPath) {
-    try {
-        return execSync('git rev-parse --short HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return 'nogit';
-    }
-}
-function getGitInfo(projectPath) {
-    try {
-        const branch = execSync('git branch --show-current', { cwd: projectPath, encoding: 'utf-8' }).trim() || 'main';
-        const lastCommit = execSync('git log -1 --pretty=%s', { cwd: projectPath, encoding: 'utf-8' }).trim() || 'No commits';
-        const author = execSync('git log -1 --pretty=%an', { cwd: projectPath, encoding: 'utf-8' }).trim() || 'Unknown';
-        const commitCount = parseInt(execSync('git rev-list --count HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim() || '0');
-        return { branch, lastCommit, author, commitCount };
-    }
-    catch {
-        return {
-            branch: 'main',
-            lastCommit: 'No commits',
-            author: 'Unknown',
-            commitCount: 0
-        };
-    }
-}
-function createNodeId(filePath, nodeName, gitHash, counter = 0) {
-    const suffix = counter > 0 ? `-${counter}` : '';
-    return `${filePath}::${nodeName}${suffix}::${gitHash}`;
-}
-function getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters) {
-    const baseKey = `${filePath}::${nodeName}`;
-    const counter = idCounters.get(baseKey) || 0;
-    const id = createNodeId(filePath, nodeName, gitHash, counter);
-    if (usedIds.has(id)) {
-        idCounters.set(baseKey, counter + 1);
-        return getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters);
-    }
-    usedIds.add(id);
-    idCounters.set(baseKey, counter + 1);
-    return id;
-}
-function isReactComponent(func) {
-    const body = func.getBody();
-    if (!body)
-        return false;
-    const text = body.getText();
-    return text.includes('return') && (text.includes('</') || text.includes('<>') || text.includes('jsx'));
-}
-function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
-    let count = 0;
-    let y = startY;
-    // Find function components
-    const functions = sourceFile.getFunctions();
-    for (const func of functions) {
-        if (isReactComponent(func)) {
-            const name = func.getName() || 'AnonymousComponent';
-            const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
-            const params = func.getParameters();
-            const propsParam = params[0];
-            const propsType = propsParam ? propsParam.getType().getText() : 'any';
-            const node = {
-                id,
-                type: 'component',
-                position: { x: baseX, y: y },
-                data: {
-                    componentName: name,
-                    props: propsType,
-                    label: name,
-                    description: `Component in ${relativePath}`,
-                }
-            };
-            nodes.push(node);
-            nodeMap.set(id, node);
-            nodeMap.set(name, node);
-            count++;
-            y += 150;
-        }
-    }
-    // Find arrow function components
-    const variables = sourceFile.getVariableDeclarations();
-    for (const variable of variables) {
-        const init = variable.getInitializer();
-        if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
-            if (isReactComponent(init)) {
-                const name = variable.getName();
-                const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
-                const params = init.getParameters();
-                const propsParam = params[0];
-                const propsType = propsParam ? propsParam.getType().getText() : 'any';
-                const node = {
-                    id,
-                    type: 'component',
-                    position: { x: baseX, y: y },
-                    data: {
-                        componentName: name,
-                        props: propsType,
-                        label: name,
-                        description: `Component in ${relativePath}`,
-                    }
-                };
-                nodes.push(node);
-                nodeMap.set(id, node);
-                nodeMap.set(name, node);
-                count++;
-                y += 150;
-            }
-        }
-    }
-    return count;
-}
-function extractFunctions(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
-    let count = 0;
-    let y = startY;
-    const functions = sourceFile.getFunctions();
-    for (const func of functions) {
-        if (!isReactComponent(func)) {
-            const name = func.getName() || 'anonymous';
-            if (name === 'anonymous')
-                continue;
-            const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
-            const params = func.getParameters().map((p) => {
-                const paramName = p.getName();
-                const paramType = p.getType().getText();
-                return `${paramName}: ${paramType}`;
-            }).join(', ');
-            const returnType = func.getReturnType().getText();
-            const node = {
-                id,
-                type: 'function',
-                position: { x: baseX, y: y },
-                data: {
-                    functionName: name,
-                    parameters: params,
-                    returnType: returnType,
-                    label: name,
-                    description: `Function in ${relativePath}`,
-                }
-            };
-            nodes.push(node);
-            nodeMap.set(id, node);
-            nodeMap.set(name, node);
-            count++;
-            y += 150;
-        }
-    }
-    return count;
-}
-function extractState(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
-    let count = 0;
-    let y = startY;
-    sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpr) => {
-        const expr = callExpr.getExpression();
-        if (expr.getText() === 'useState') {
-            const parent = callExpr.getParent();
-            if (Node.isVariableDeclaration(parent)) {
-                const nameNode = parent.getNameNode();
-                if (Node.isArrayBindingPattern(nameNode)) {
-                    const elements = nameNode.getElements();
-                    if (elements.length > 0) {
-                        const stateName = elements[0].getText();
-                        const id = getUniqueNodeId(relativePath, stateName, gitHash, usedIds, idCounters);
-                        const args = callExpr.getArguments();
-                        const initialValue = args.length > 0 ? args[0].getText() : 'undefined';
-                        const stateType = parent.getType().getText();
-                        const node = {
-                            id,
-                            type: 'state',
-                            position: { x: baseX, y: y },
-                            data: {
-                                stateName: stateName,
-                                stateType: stateType,
-                                initialValue: initialValue,
-                                label: stateName,
-                                description: `State in ${relativePath}`,
-                            }
-                        };
-                        nodes.push(node);
-                        nodeMap.set(id, node);
-                        nodeMap.set(stateName, node);
-                        count++;
-                        y += 150;
-                    }
-                }
-            }
-        }
-    });
-    return count;
-}
-function generateEdges(sourceFile, nodeMap, edges) {
-    // Find JSX elements (component usage)
-    sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach((jsxElement) => {
-        const openingElement = jsxElement.getOpeningElement();
-        const tagName = openingElement.getTagNameNode().getText();
-        const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ||
-            jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
-        if (containingFunc) {
-            const parentName = containingFunc.getName?.() ||
-                containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() ||
-                null;
-            if (parentName && nodeMap.has(parentName) && nodeMap.has(tagName)) {
-                const sourceNode = nodeMap.get(parentName);
-                const targetNode = nodeMap.get(tagName);
-                if (sourceNode && targetNode) {
-                    const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
-                    if (!edges.find(e => e.id === edgeId)) {
-                        edges.push({
-                            id: edgeId,
-                            source: sourceNode.id,
-                            target: targetNode.id,
-                            type: 'floating',
-                        });
-                    }
-                }
-            }
-        }
-    });
-    // Find self-closing JSX elements
-    sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach((jsxElement) => {
-        const tagName = jsxElement.getTagNameNode().getText();
-        const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ||
-            jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
-        if (containingFunc) {
-            const parentName = containingFunc.getName?.() ||
-                containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() ||
-                null;
-            if (parentName && nodeMap.has(parentName) && nodeMap.has(tagName)) {
-                const sourceNode = nodeMap.get(parentName);
-                const targetNode = nodeMap.get(tagName);
-                if (sourceNode && targetNode) {
-                    const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
-                    if (!edges.find(e => e.id === edgeId)) {
-                        edges.push({
-                            id: edgeId,
-                            source: sourceNode.id,
-                            target: targetNode.id,
-                            type: 'floating',
-                        });
-                    }
-                }
-            }
-        }
-    });
-    // Find function calls
-    sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpr) => {
-        const expr = callExpr.getExpression();
-        const calledName = expr.getText().split('.').pop();
-        if (calledName && nodeMap.has(calledName)) {
-            const containingFunc = callExpr.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ||
-                callExpr.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
-            if (containingFunc) {
-                const parentName = containingFunc.getName?.() ||
-                    containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() ||
-                    null;
-                if (parentName && nodeMap.has(parentName)) {
-                    const sourceNode = nodeMap.get(parentName);
-                    const targetNode = nodeMap.get(calledName);
-                    if (sourceNode && targetNode && sourceNode.id !== targetNode.id) {
-                        const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
-                        if (!edges.find(e => e.id === edgeId)) {
-                            edges.push({
-                                id: edgeId,
-                                source: sourceNode.id,
-                                target: targetNode.id,
-                                type: 'floating',
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    });
-}

package/dist/git-utils.d.ts

@@ -1,33 +0,0 @@
-/**
- * Git Utilities
- *
- * Helper functions to interact with git repositories
- */
-/**
- * Get list of uncommitted changed files in a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths that have uncommitted changes
- */
-export declare function getUncommittedChanges(projectPath: any): string[];
-/**
- * Check if a directory is a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {boolean}
- */
-export declare function isGitRepository(projectPath: any): boolean;
-/**
- * Get list of untracked files in a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths that are untracked
- */
-export declare function getUntrackedFiles(projectPath: any): string[];
-/**
- * Get all files with changes (committed or not)
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths
- */
-export declare function getAllChangedFiles(projectPath: any): string[];

package/dist/git-utils.js

@@ -1,96 +0,0 @@
-import { execSync } from 'child_process';
-import path from 'path';
-/**
- * Git Utilities
- *
- * Helper functions to interact with git repositories
- */
-/**
- * Get list of uncommitted changed files in a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths that have uncommitted changes
- */
-export function getUncommittedChanges(projectPath) {
-    try {
-        // Check if directory is a git repository
-        if (!isGitRepository(projectPath)) {
-            return [];
-        }
-        // Get modified, added, and deleted files (staged and unstaged)
-        const command = 'git diff --name-only HEAD && git diff --name-only --cached';
-        const output = execSync(command, {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'ignore'], // Ignore stderr
-        });
-        // Parse output and convert to absolute paths
-        const files = output
-            .split('\n')
-            .filter(Boolean)
-            .map(file => path.resolve(projectPath, file.trim()));
-        // Remove duplicates
-        return [...new Set(files)];
-    }
-    catch (error) {
-        // If git command fails, return empty array
-        console.error('Failed to get git diff:', error.message);
-        return [];
-    }
-}
-/**
- * Check if a directory is a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {boolean}
- */
-export function isGitRepository(projectPath) {
-    try {
-        execSync('git rev-parse --is-inside-work-tree', {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'ignore'],
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get list of untracked files in a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths that are untracked
- */
-export function getUntrackedFiles(projectPath) {
-    try {
-        if (!isGitRepository(projectPath)) {
-            return [];
-        }
-        const output = execSync('git ls-files --others --exclude-standard', {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'ignore'],
-        });
-        return output
-            .split('\n')
-            .filter(Boolean)
-            .map(file => path.resolve(projectPath, file.trim()));
-    }
-    catch (error) {
-        console.error('Failed to get untracked files:', error.message);
-        return [];
-    }
-}
-/**
- * Get all files with changes (committed or not)
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths
- */
-export function getAllChangedFiles(projectPath) {
-    const uncommitted = getUncommittedChanges(projectPath);
-    const untracked = getUntrackedFiles(projectPath);
-    return [...new Set([...uncommitted, ...untracked])];
-}

package/dist/incremental-analyzer.d.ts

@@ -1,128 +0,0 @@
-/**
- * Incremental Analyzer
- *
- * Performs incremental analysis by comparing new analysis results with
- * previously stored results and generating a diff of changes.
- */
-/**
- * Perform incremental analysis on a project
- *
- * @param {string} projectId - Project identifier
- * @param {string} projectPath - Absolute path to project
- * @param {string[]} changedFiles - Optional array of changed file paths
- * @returns {Object} - Incremental update with added, removed, and modified nodes/edges
- */
-export declare function performIncrementalAnalysis(projectId: any, projectPath: any, changedFiles?: any[]): {
-    type: string;
-    analysis: Promise<{
-        project: {
-            id: string;
-            value: string;
-            title: string;
-            subtitle: string;
-            trend: number;
-            chartData: number[];
-            chartColor: string;
-        };
-        branches: {
-            id: string;
-            status: string;
-            name: string;
-            lastCommit: string;
-            lastCommitDate: string;
-            author: string;
-            commitCount: number;
-            pullRequests: number;
-        }[];
-        planData: Record<string, {
-            nodes: {
-                id: string;
-                type: "function" | "component" | "state" | "api" | "conditional" | "ternary" | "switch" | "try-catch" | "task";
-                position: {
-                    x: number;
-                    y: number;
-                };
-                data: {
-                    label: string;
-                    description?: string | undefined;
-                    componentName?: string | undefined;
-                    props?: string | undefined;
-                    functionName?: string | undefined;
-                    parameters?: string | undefined;
-                    returnType?: string | undefined;
-                    stateName?: string | undefined;
-                    stateType?: string | undefined;
-                    initialValue?: string | undefined;
-                    method?: string | undefined;
-                    endpoint?: string | undefined;
-                    responseType?: string | undefined;
-                    condition?: string | undefined;
-                    trueLabel?: string | undefined;
-                    falseLabel?: string | undefined;
-                    ternaryCondition?: string | undefined;
-                    ternaryTrue?: string | undefined;
-                    ternaryFalse?: string | undefined;
-                    trueValue?: string | undefined;
-                    falseValue?: string | undefined;
-                    switchExpression?: string | undefined;
-                    cases?: string | undefined;
-                    tryBlock?: string | undefined;
-                    catchBlock?: string | undefined;
-                };
-            }[];
-            edges: {
-                id: string;
-                type: string;
-                source: string;
-                target: string;
-                label?: string | undefined;
-                sourceHandle?: string | undefined;
-                targetHandle?: string | undefined;
-            }[];
-        }>;
-        analyzedAt: string;
-        logs?: string[] | undefined;
-    }>;
-    update: {
-        added: {
-            nodes: any[];
-            edges: any[];
-        };
-        removed: {
-            nodeIds: any[];
-            edgeIds: any[];
-        };
-        modified: {
-            nodes: any[];
-            edges: any[];
-        };
-    };
-};
-/**
- * Generate diff between old and new analysis
- *
- * @param {Object} oldAnalysis - Previous analysis data
- * @param {Object} newAnalysis - New analysis data
- * @returns {Object} - Incremental update object
- */
-export declare function generateDiff(oldAnalysis: any, newAnalysis: any): {
-    added: {
-        nodes: any[];
-        edges: any[];
-    };
-    removed: {
-        nodeIds: any[];
-        edgeIds: any[];
-    };
-    modified: {
-        nodes: any[];
-        edges: any[];
-    };
-};
-/**
- * Check if an update has any changes
- *
- * @param {Object} update - Incremental update object
- * @returns {boolean}
- */
-export declare function hasChanges(update: any): boolean;