projectify-cli 1.0.0

package/dist/graph/index.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraph = void 0;
+const path_1 = __importDefault(require("path"));
+class DependencyGraph {
+    constructor(analysis) {
+        this.analysis = analysis;
+        this.nodes = new Map();
+        this.edges = new Map(); // From -> Set<To>
+        this.reverseEdges = new Map(); // To -> Set<From>
+        this.buildGraph();
+        this.calculateMetrics();
+    }
+    buildGraph() {
+        // strict node handling
+        Object.keys(this.analysis.files).forEach(file => {
+            this.nodes.set(file, {
+                id: file,
+                inDegree: 0,
+                outDegree: 0,
+                blastRadius: 0,
+                affectedFiles: 0
+            });
+            this.edges.set(file, new Set());
+            this.reverseEdges.set(file, new Set());
+        });
+        Object.entries(this.analysis.files).forEach(([filePath, fileData]) => {
+            fileData.imports.forEach(importPath => {
+                const resolvedPath = this.resolveImport(filePath, importPath);
+                if (resolvedPath && this.nodes.has(resolvedPath)) {
+                    this.addEdge(filePath, resolvedPath);
+                }
+            });
+        });
+    }
+    resolveImport(sourceFile, importPath) {
+        const dir = path_1.default.dirname(sourceFile);
+        const possibleExtensions = ['', '.js', '.ts', '.jsx', '.tsx', '.py'];
+        // 1. Check relative imports (starts with .)
+        if (importPath.startsWith('.')) {
+            for (const ext of possibleExtensions) {
+                const resolved = path_1.default.resolve(dir, importPath + ext);
+                if (this.nodes.has(resolved))
+                    return resolved;
+                const indexResolved = path_1.default.resolve(dir, importPath, 'index' + ext);
+                if (this.nodes.has(indexResolved))
+                    return indexResolved;
+                // Python __init__
+                const initResolved = path_1.default.resolve(dir, importPath, '__init__.py');
+                if (this.nodes.has(initResolved))
+                    return initResolved;
+            }
+        }
+        // 2. Check Python module imports (e.g. 'analyzer.scanner' -> 'analyzer/scanner.py')
+        else if (!importPath.startsWith('/') && !importPath.startsWith('@')) {
+            const pyPath = importPath.replace(/\./g, '/');
+            // Try resolving from root (simplified assumption for now, ideally scan PYTHONPATH)
+            // We'll try relative first for simple cases, then "absolute" from project root
+            // Try relative to current file (Python often allows this implicitly in packages)
+            for (const ext of possibleExtensions) {
+                const resolved = path_1.default.resolve(dir, pyPath + ext);
+                if (this.nodes.has(resolved))
+                    return resolved;
+                const initResolved = path_1.default.resolve(dir, pyPath, '__init__.py');
+                if (this.nodes.has(initResolved))
+                    return initResolved;
+            }
+            // Try from project root (we don't easily know project root here, but we can guess it's where package.json is, 
+            // OR we can iterate all nodes to find a match - expensive but correct for "Project" analyzer)
+            // A faster way is to map "fileName" -> fullPath in a separate index. 
+            // For now, let's skip complex root resolution to keep it simple.
+        }
+        return null;
+    }
+    addEdge(from, to) {
+        if (!this.edges.get(from)?.has(to)) {
+            this.edges.get(from)?.add(to);
+            this.reverseEdges.get(to)?.add(from);
+            const fromNode = this.nodes.get(from);
+            const toNode = this.nodes.get(to);
+            fromNode.outDegree++;
+            toNode.inDegree++;
+        }
+    }
+    calculateMetrics() {
+        this.nodes.forEach(node => {
+            const dependents = this.getAllDependents(node.id);
+            node.affectedFiles = dependents.size;
+            node.blastRadius = (dependents.size / this.nodes.size) * 100;
+        });
+    }
+    getAllDependents(nodeId) {
+        const dependents = new Set();
+        const queue = [nodeId];
+        const visited = new Set([nodeId]);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const incoming = this.reverseEdges.get(current);
+            if (incoming) {
+                incoming.forEach(src => {
+                    if (!visited.has(src)) {
+                        visited.add(src);
+                        dependents.add(src);
+                        queue.push(src);
+                    }
+                });
+            }
+        }
+        return dependents;
+    }
+    getTopBlastRadius(limit = 5) {
+        return Array.from(this.nodes.values())
+            .sort((a, b) => b.blastRadius - a.blastRadius)
+            .slice(0, limit);
+    }
+    getNodes() {
+        return this.nodes;
+    }
+    getEdges() {
+        return this.edges;
+    }
+}
+exports.DependencyGraph = DependencyGraph;

package/dist/index.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const scanner_1 = require("./scanner");
+const analyzer_1 = require("./analyzer");
+const graph_1 = require("./graph");
+const ai_1 = require("./ai");
+const gitUtils_1 = require("./utils/gitUtils");
+const program = new commander_1.Command();
+program
+    .name('projectify')
+    .description('Projectify - Autonomous Code Analysis & Visualization')
+    .version('2.0.0');
+program
+    .argument('[path]', 'Project path to analyze', '.')
+    .option('--no-ai', 'Skip AI analysis')
+    .option('--summary', 'Generate full project summary')
+    .option('--provider <type>', 'AI Provider (openai, gemini, ollama)', 'openai')
+    .option('--model <name>', 'Model name (optional)')
+    .action(async (projectPath, options) => {
+    try {
+        console.log(chalk_1.default.blue(`🚀 Starting analysis for: ${projectPath}`));
+        // 1. Scan
+        console.log(chalk_1.default.yellow('scanning files...'));
+        const files = await (0, scanner_1.scanProject)({ path: projectPath });
+        console.log(chalk_1.default.green(`found ${files.length} files.`));
+        // 2. Analyze
+        console.log(chalk_1.default.yellow('parsing codebase...'));
+        const analysis = await (0, analyzer_1.analyzeFiles)(files);
+        // 3. Git Analysis
+        console.log(chalk_1.default.yellow('analyzing git history...'));
+        const gitService = new gitUtils_1.GitService(projectPath);
+        const gitStats = await gitService.getAnalysis();
+        if (gitStats) {
+            console.log(chalk_1.default.green(`git history found: ${gitStats.totalCommits} commits, ${gitStats.authroStats.length} authors.`));
+        }
+        else {
+            console.log(chalk_1.default.gray('no git repository found or git error.'));
+        }
+        // 4. Build Graph
+        console.log(chalk_1.default.yellow('building dependency graph...'));
+        const graph = new graph_1.DependencyGraph(analysis);
+        const topRisks = graph.getTopBlastRadius(5);
+        console.log(chalk_1.default.bold.underline('\n🔥 Top Blast Radius Risks:'));
+        topRisks.forEach(node => {
+            console.log(`${chalk_1.default.cyan(path_1.default.basename(node.id))} : ${chalk_1.default.red(node.blastRadius.toFixed(1) + '%')} impact (${node.affectedFiles} files)`);
+        });
+        // 5. AI Analysis
+        let ai = null;
+        let projectSummary = '';
+        let gitInsight = '';
+        if (options.ai) {
+            const providerType = options.provider;
+            let apiKey = '';
+            if (providerType === 'openai') {
+                apiKey = process.env.OPENAI_API_KEY || '';
+                if (!apiKey)
+                    console.log(chalk_1.default.red('\n⚠️  OPENAI_API_KEY not found.'));
+            }
+            else if (providerType === 'gemini') {
+                apiKey = process.env.GEMINI_API_KEY || '';
+                if (!apiKey)
+                    console.log(chalk_1.default.red('\n⚠️  GEMINI_API_KEY not found.'));
+            }
+            if ((providerType === 'ollama') || apiKey) {
+                try {
+                    console.log(chalk_1.default.blue(`\n🧠 Initializing AI (${providerType})...`));
+                    ai = new ai_1.CodeIntelligence(providerType, apiKey, options.model);
+                    // Analyze the highest risk file
+                    if (topRisks.length > 0) {
+                        const riskiest = topRisks[0];
+                        console.log(chalk_1.default.gray(`Analyzing ${path_1.default.basename(riskiest.id)}...`));
+                        const insight = await ai.analyzeBlastRadius(riskiest);
+                        console.log(chalk_1.default.white(insight));
+                    }
+                    // Detailed Project Summary
+                    if (options.summary) {
+                        console.log(chalk_1.default.blue('\n🧠 Generating Project Summary...'));
+                        const fileList = Object.keys(analysis.files);
+                        projectSummary = await ai.generateProjectSummary(analysis.fileCount, topRisks, fileList);
+                        console.log(chalk_1.default.white(chalk_1.default.bold('\nProject Overview:\n') + projectSummary));
+                    }
+                    // Git Evolution Insight
+                    if (gitStats) {
+                        console.log(chalk_1.default.blue('\n🧠 Analyzing Project Evolution...'));
+                        gitInsight = await ai.analyzeGitHistory(gitStats);
+                        console.log(chalk_1.default.white(chalk_1.default.bold('\nGit Insights:\n') + gitInsight));
+                    }
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`AI Initialization failed: ${e.message}`));
+                }
+            }
+        }
+        // 6. Save Report
+        const reportPath = path_1.default.resolve('analysis-report.json');
+        await fs_extra_1.default.writeJSON(reportPath, {
+            timestamp: new Date(),
+            files: analysis.fileCount,
+            topRisks,
+            gitAnalysis: gitStats,
+            aiInsights: {
+                projectSummary,
+                gitInsight
+            },
+            fullAnalysis: analysis
+        }, { spaces: 2 });
+        console.log(chalk_1.default.green(`\n✅ JSON Report saved to ${reportPath}`));
+        const htmlPath = path_1.default.resolve('analysis-report.html');
+        const { generateHtmlReport } = require('./report/htmlGenerator');
+        // Check if we need to pass new data to html generator. 
+        // For now, we just pass the same args, assuming HTML generator might need updates later 
+        // but the JSON report is the source of truth for raw data.
+        await generateHtmlReport(projectPath, analysis, graph, htmlPath, gitStats);
+        console.log(chalk_1.default.green(`✅ HTML Graph saved to ${htmlPath}`));
+        // Save Summary MD
+        if (projectSummary) {
+            const summaryPath = path_1.default.resolve('project-summary.md');
+            const content = `# Project Summary\n\n${projectSummary}\n\n## Evolution Insights\n\n${gitInsight}`;
+            await fs_extra_1.default.writeFile(summaryPath, content);
+            console.log(chalk_1.default.green(`✅ Summary saved to ${summaryPath}`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Analysis failed:'), error);
+        process.exit(1);
+    }
+});
+program.parse();