analyze-codebase 1.0.0

package/.env.development

@@ -0,0 +1 @@
+EXAMPLE_SCRIPT= "yarn cli ../../projects/PowerDev-Portal/ --extensions .js .ts .tsx .jsx --exclude node_modules public .log .next"

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Taha GÖÇER
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/analyze/file/fileName.d.ts

@@ -0,0 +1 @@
+export declare const analyzeFileName: (filePath: string) => import("../../utils").NamingCase;

package/dist/analyze/file/fileName.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFileName = void 0;
+const path = __importStar(require("path"));
+const utils_1 = require("../../utils");
+const analyzeFileName = (filePath) => {
+    // Example: Check if file name contains uppercase characters
+    const fileName = path.basename(filePath);
+    const fileNameWithoutExtension = fileName.split(path.extname(fileName))[0];
+    return (0, utils_1.whatCase)(fileNameWithoutExtension);
+};
+exports.analyzeFileName = analyzeFileName;

package/dist/analyze/file/index.d.ts

@@ -0,0 +1,4 @@
+import { ICodeContentType } from '../../types';
+export declare const analyzeFile: (filePath: string, output: ICodeContentType) => {
+    fileNameCase: import("../../utils").NamingCase;
+};

package/dist/analyze/file/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFile = void 0;
+const path = __importStar(require("path"));
+const fileName_1 = require("../../analyze/file/fileName");
+const lineCount_1 = require("../../analyze/sourceCode/lineCount");
+const analyzeFile = (filePath, output) => {
+    const fileName = path.basename(filePath);
+    const fileNameCase = (0, fileName_1.analyzeFileName)(fileName);
+    (0, lineCount_1.analyzeLineCountByCategory)(filePath, output);
+    return { fileNameCase };
+};
+exports.analyzeFile = analyzeFile;

package/dist/analyze/index.d.ts

@@ -0,0 +1,2 @@
+import { IAnalysisOptions } from '../types';
+export declare const analyzeCodebase: (options: IAnalysisOptions) => Promise<void>;

package/dist/analyze/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCodebase = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const file_1 = require("../analyze/file");
+const file_2 = require("../utils/file");
+const output_1 = require("../utils/output");
+const analyzeCodebase = async (options) => {
+    const start = Date.now();
+    const fileNameCases = {};
+    const output = {
+        Physical: 0,
+        Source: 0,
+        Comment: 0,
+        SingleLineComment: 0,
+        BlockComment: 0,
+        Mixed: 0,
+        EmptyBlockComment: 0,
+        Empty: 0,
+        ToDo: 0
+    };
+    console.log(chalk_1.default.bold(`\n\nAnalyzing codebase in ${chalk_1.default.cyan(options.directory)} ${(options === null || options === void 0 ? void 0 : options.framework) ? `framework: ${chalk_1.default.cyan(options.framework)}` : ""}\n`));
+    let fileCount = 0;
+    await (0, file_2.traverseDirectory)({
+        extensions: options.extensions,
+        directory: options.directory,
+        exclude: options.exclude,
+        checkFileNames: options.checkFileNames,
+        onFile: (filePath) => {
+            fileCount++;
+            const { fileNameCase } = (0, file_1.analyzeFile)(filePath, output);
+            //@ts-ignore
+            if (fileNameCases[fileNameCase] !== undefined)
+                fileNameCases[fileNameCase] += 1;
+            else
+                fileNameCases[fileNameCase] = 0;
+        }
+    });
+    (0, output_1.logOutput)({
+        fileCount,
+        fileNameCases,
+        options,
+        output
+    });
+    const totalSecond = ((Date.now() - start) / 1000).toFixed(2);
+    console.log(chalk_1.default.bold(`Time taken: ${chalk_1.default.yellow(totalSecond)}s\n`));
+};
+exports.analyzeCodebase = analyzeCodebase;

package/dist/analyze/sourceCode/lineCount.d.ts

@@ -0,0 +1,12 @@
+import { ICodeContentType } from '../../types';
+/**
+ * Analyze the line count of the specified file
+ */
+export declare const analyzeLineCount: (filePath: string) => number;
+export declare const isSingleLineComment: (line?: string) => boolean;
+export declare const isBlockComment: (line?: string) => boolean;
+export declare const isMixedComment: (line?: string) => boolean;
+export declare const isEmptyBlockComment: (line?: string) => boolean;
+export declare const isComment: (line?: string) => boolean;
+export declare const isToDo: (line?: string) => boolean;
+export declare const analyzeLineCountByCategory: (filePath: string, output: ICodeContentType) => ICodeContentType;

package/dist/analyze/sourceCode/lineCount.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeLineCountByCategory = exports.isToDo = exports.isComment = exports.isEmptyBlockComment = exports.isMixedComment = exports.isBlockComment = exports.isSingleLineComment = exports.analyzeLineCount = void 0;
+const fs = __importStar(require("fs"));
+/**
+ * Analyze the line count of the specified file
+ */
+const analyzeLineCount = (filePath) => {
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    return fileContent.split('\n').length;
+};
+exports.analyzeLineCount = analyzeLineCount;
+const isSingleLineComment = (line = "") => line.startsWith('//');
+exports.isSingleLineComment = isSingleLineComment;
+const isBlockComment = (line = "") => line.startsWith('/*') && line.endsWith('*/');
+exports.isBlockComment = isBlockComment;
+const isMixedComment = (line = "") => (line.startsWith('/*') && !line.endsWith('*/')) || line.startsWith('*');
+exports.isMixedComment = isMixedComment;
+const isEmptyBlockComment = (line = "") => line.startsWith('/*') && !line.endsWith('*/');
+exports.isEmptyBlockComment = isEmptyBlockComment;
+const isComment = (line = "") => {
+    return (0, exports.isSingleLineComment)(line) || (0, exports.isBlockComment)(line) || (0, exports.isMixedComment)(line) || (0, exports.isEmptyBlockComment)(line);
+};
+exports.isComment = isComment;
+const isToDo = (line = "") => {
+    return (line.includes('TODO'));
+};
+exports.isToDo = isToDo;
+const analyzeLineCountByCategory = (filePath, output) => {
+    var _a;
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    const lines = fileContent.split('\n') || "";
+    let lineIndex = 0;
+    while (lineIndex < lines.length) {
+        const line = lines[lineIndex].trim();
+        output.Physical++;
+        if (line === '')
+            output.Empty++;
+        else if ((0, exports.isSingleLineComment)(line)) {
+            output.SingleLineComment++;
+            output.Comment++;
+        }
+        else if ((0, exports.isBlockComment)(line)) {
+            output.BlockComment++;
+            output.Comment++;
+        }
+        else if ((0, exports.isMixedComment)(line)) {
+            output.Mixed++;
+            output.Comment++;
+            let blockCommentLines = 0;
+            while (lineIndex < lines.length && !((_a = lines[lineIndex]) === null || _a === void 0 ? void 0 : _a.endsWith('*/'))) {
+                blockCommentLines++;
+                lineIndex++;
+            }
+            if ((0, exports.isEmptyBlockComment)(line))
+                output.EmptyBlockComment += blockCommentLines;
+            else
+                output.BlockComment += blockCommentLines;
+        }
+        if ((0, exports.isToDo)(line))
+            output.ToDo++;
+        lineIndex++;
+    }
+    output.Source = output.Physical - output.Comment - output.Empty - output.ToDo;
+    return output;
+};
+exports.analyzeLineCountByCategory = analyzeLineCountByCategory;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const runner_1 = __importDefault(require("./runner"));
+chalk_1.default.level = 3;
+commander_1.program
+    .arguments('<directory>')
+    .description('Analyze the specified directory')
+    .option('-f, --framework <framework>', 'Specify the framework')
+    .option('-e, --extensions <extensions...>', 'Specify the extensions', (value, previous) => previous.concat(value), [])
+    .option('-exc, --exclude <exclude...>', 'Specify the exclude', (value, previous) => previous.concat(value), [])
+    .option('--checkFileNames [checkFileNames]', 'Check file names', parseBoolean)
+    .option('--checkFileContent [checkFileContent]', 'Check directories', parseBoolean)
+    .action((directory, options) => {
+    var _a, _b, _c;
+    if (options.checkFileNames === false && options.checkFileContent === false) {
+        return console.error(chalk_1.default.red(`\nError: You must specify ${chalk_1.default.yellow("true")} at least one of the following options: ${chalk_1.default.yellow("--checkFileNames")}, ${chalk_1.default.yellow("--checkFileContent")}\n`));
+    }
+    if ((_a = options === null || options === void 0 ? void 0 : options.extensions) === null || _a === void 0 ? void 0 : _a.find((d) => !d.includes('.'))) {
+        return console.error(chalk_1.default.red('\nError: Extensions must include a dot (.)\n'));
+    }
+    (0, runner_1.default)({ ...options, directory, checkFileContent: (_b = options.checkFileContent) !== null && _b !== void 0 ? _b : true, checkFileNames: (_c = options.checkFileNames) !== null && _c !== void 0 ? _c : true });
+});
+commander_1.program.parse(process.argv);
+function parseBoolean(value) {
+    if (typeof value === 'undefined') {
+        return undefined;
+    }
+    return value.toLowerCase() === 'true';
+}

package/dist/runner.d.ts

@@ -0,0 +1,5 @@
+import { IAnalysisOptions } from "./types";
+export interface IRunnerProps extends IAnalysisOptions {
+    directory: string;
+}
+export default function runner(props: IRunnerProps): void;

package/dist/runner.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const analyze_1 = require("./analyze");
+function runner(props) {
+    (0, analyze_1.analyzeCodebase)(props);
+}
+exports.default = runner;

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+export interface IAnalysisOptions {
+    directory: string;
+    framework?: string;
+    extensions?: string[];
+    exclude?: string[];
+    conventions?: string[];
+    checkFileNames?: boolean;
+    checkFileContent?: boolean;
+}
+export interface IViolation {
+    filePath: string;
+    message: string;
+    type: string;
+}
+export interface Identifier {
+    name: string;
+    line: number;
+}
+export interface ICodeContentType {
+    Physical: number;
+    Source: number;
+    Comment: number;
+    SingleLineComment: number;
+    BlockComment: number;
+    Mixed: number;
+    EmptyBlockComment: number;
+    Empty: number;
+    ToDo: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/file.d.ts

@@ -0,0 +1,9 @@
+export interface ITraverseDirectoryProps {
+    directory: string;
+    exclude?: string[];
+    extensions?: string[];
+    checkFileNames?: boolean;
+    onFile: (filePath: string) => void;
+    onDirectory?: (dirPath: string) => void;
+}
+export declare const traverseDirectory: ({ directory, onFile, onDirectory, exclude, extensions, checkFileNames, }: ITraverseDirectoryProps) => Promise<void>;

package/dist/utils/file.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseDirectory = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const traverseDirectory = async ({ directory, onFile, onDirectory, exclude, extensions, checkFileNames = true, }) => {
+    const files = await fs.readdir(directory, { withFileTypes: true });
+    const tasks = files.map(async (file) => {
+        const filePath = path.join(directory, file.name);
+        if (exclude === null || exclude === void 0 ? void 0 : exclude.length) {
+            if (exclude.includes(file.name))
+                return;
+        }
+        if (file.isDirectory()) {
+            onDirectory === null || onDirectory === void 0 ? void 0 : onDirectory(filePath);
+            await (0, exports.traverseDirectory)({
+                directory: filePath,
+                onFile,
+                exclude,
+                extensions,
+                onDirectory,
+                checkFileNames,
+            });
+        }
+        else if (checkFileNames) {
+            const ext = path.extname(file.name);
+            if (extensions === null || extensions === void 0 ? void 0 : extensions.length) {
+                if (extensions.includes(ext))
+                    onFile(filePath);
+            }
+            else
+                onFile(filePath);
+        }
+    });
+    await Promise.all(tasks);
+};
+exports.traverseDirectory = traverseDirectory;

package/dist/utils/index.d.ts

@@ -0,0 +1,23 @@
+export declare enum NamingCase {
+    CamelCase = "CamelCase",
+    PascalCase = "PascalCase",
+    SnakeCase = "SnakeCase",
+    UpperCase = "UpperCase",
+    LowerCase = "LowerCase",
+    KebabCase = "KebabCase",
+    StartCase = "StartCase",
+    DotCase = "DotCase",
+    PathCase = "PathCase",
+    SpaceCase = "SpaceCase",
+    NoCase = "NoCase",
+    ConstantCase = "ConstantCase",
+    SentenceCase = "SentenceCase",
+    Unknown = "Unknown"
+}
+export declare const NamingCases: Record<NamingCase, RegExp>;
+export declare const NamingCasesArray: {
+    regexp: RegExp;
+    type: NamingCase;
+}[];
+export declare const controlCase: (str: string, caseType: NamingCase) => boolean;
+export declare const whatCase: (str: string) => NamingCase;

package/dist/utils/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whatCase = exports.controlCase = exports.NamingCasesArray = exports.NamingCases = exports.NamingCase = void 0;
+var NamingCase;
+(function (NamingCase) {
+    NamingCase["CamelCase"] = "CamelCase";
+    NamingCase["PascalCase"] = "PascalCase";
+    NamingCase["SnakeCase"] = "SnakeCase";
+    NamingCase["UpperCase"] = "UpperCase";
+    NamingCase["LowerCase"] = "LowerCase";
+    NamingCase["KebabCase"] = "KebabCase";
+    NamingCase["StartCase"] = "StartCase";
+    NamingCase["DotCase"] = "DotCase";
+    NamingCase["PathCase"] = "PathCase";
+    NamingCase["SpaceCase"] = "SpaceCase";
+    NamingCase["NoCase"] = "NoCase";
+    NamingCase["ConstantCase"] = "ConstantCase";
+    NamingCase["SentenceCase"] = "SentenceCase";
+    NamingCase["Unknown"] = "Unknown";
+})(NamingCase = exports.NamingCase || (exports.NamingCase = {}));
+exports.NamingCases = {
+    [NamingCase.CamelCase]: /^[a-z][a-zA-Z0-9]*$/,
+    [NamingCase.PascalCase]: /^[A-Z][a-zA-Z0-9]*$/,
+    [NamingCase.SnakeCase]: /^[a-z][a-z0-9_]*$/,
+    [NamingCase.UpperCase]: /^[A-Z][A-Z0-9]*$/,
+    [NamingCase.LowerCase]: /^[a-z][a-z0-9]*$/,
+    [NamingCase.KebabCase]: /^[a-z][a-z0-9-]*$/,
+    [NamingCase.StartCase]: /^[A-Z][a-z0-9 ]*$/,
+    [NamingCase.DotCase]: /^[a-z][a-z0-9.]*$/,
+    [NamingCase.PathCase]: /^[a-z][a-z0-9/]*$/,
+    [NamingCase.SpaceCase]: /^[a-z][a-z0-9 ]*$/,
+    [NamingCase.NoCase]: /^[a-z][a-z0-9]*$/,
+    [NamingCase.ConstantCase]: /^[A-Z][A-Z0-9_]*$/,
+    [NamingCase.SentenceCase]: /^[A-Z][a-z0-9 ]*$/,
+    [NamingCase.Unknown]: /^.*$/
+};
+exports.NamingCasesArray = Object.entries(exports.NamingCases).map(([type, regexp]) => ({
+    regexp,
+    type: type
+}));
+const controlCase = (str, caseType) => exports.NamingCases[caseType].test(str);
+exports.controlCase = controlCase;
+const whatCase = (str) => { var _a; return ((_a = exports.NamingCasesArray.find(({ regexp }) => regexp.test(str))) === null || _a === void 0 ? void 0 : _a.type) || NamingCase.Unknown; };
+exports.whatCase = whatCase;

package/dist/utils/output.d.ts

@@ -0,0 +1,9 @@
+import { NamingCase } from ".";
+import { IAnalysisOptions, ICodeContentType } from "../types";
+export interface IParams {
+    output: ICodeContentType;
+    fileCount: number;
+    options: IAnalysisOptions;
+    fileNameCases: Partial<Record<NamingCase, number>>;
+}
+export declare const logOutput: ({ fileCount, output, fileNameCases, options }: IParams) => void;

package/dist/utils/output.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logOutput = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const logOutput = ({ fileCount, output, fileNameCases, options }) => {
+    console.log(chalk_1.default.bold('------------- Result -------------\n'));
+    if (fileCount === 0) {
+        console.log(chalk_1.default.red(`No files found in ${chalk_1.default.cyan(options.directory)} with extensions ${chalk_1.default.cyan(options.extensions)}\n`));
+    }
+    else {
+        if (options.checkFileNames) {
+            console.log(chalk_1.default.bold('File Name Summary:\n'));
+            const fileNameTable = new cli_table3_1.default({
+                head: [chalk_1.default.bold('File Name Case'), chalk_1.default.bold('Count'), chalk_1.default.bold('Percentage')],
+                colWidths: [30, 10, 15],
+            });
+            Object.entries(fileNameCases).forEach(([key, value]) => {
+                const percentage = ((value / fileCount) * 100).toFixed(2);
+                fileNameTable.push([key, value.toString(), `${percentage}%`]);
+            });
+            console.log(fileNameTable.toString());
+            console.log('\n');
+        }
+        if (options.checkFileContent) {
+            console.log(chalk_1.default.bold('Content Type Summary:\n'));
+            const contentTypeTable = new cli_table3_1.default({
+                head: [chalk_1.default.bold('Content Type'), chalk_1.default.bold('Count'), chalk_1.default.bold('Percentage')],
+                colWidths: [30, 10, 15],
+            });
+            Object.entries(output).forEach(([key, value]) => {
+                const percentage = ((value / output.Physical) * 100).toFixed(2);
+                contentTypeTable.push([key, value.toString(), `${percentage}%`]);
+            });
+            console.log(contentTypeTable.toString());
+        }
+    }
+    console.log(chalk_1.default.bold('\n----------------------------'));
+    console.log(chalk_1.default.bold(`\nNumber of files read: ${chalk_1.default.yellow(fileCount)}\n`));
+};
+exports.logOutput = logOutput;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "analyze-codebase",
+  "description": "Codebase Analyzer",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mtahagocer/analyze-codebase"
+  },
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "bin": {
+    "analyze-project": "dist/index.js"
+  },
+  "scripts": {
+    "cli": "ts-node ./src/index.ts",
+    "start": "node ./dist/index.js",
+    "compile": "npx rimraf dist && npx tsc"
+  },
+  "contributes": {
+    "commands": [
+      {
+        "command": "extension.analyzeCode",
+        "title": "Analyze Codebase"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.1.5",
+    "typescript": "^5.0.4",
+    "ts-node": "^10.9.1"
+  },
+  "dependencies": {
+    "chalk": "4.1.0",
+    "cli-table3": "^0.6.3",
+    "commander": "^10.0.1"
+  }
+}

package/readme.md

@@ -0,0 +1,132 @@
+
+# Codebase Analyzer
+
+Codebase Analyzer is a command-line tool that analyzes a specified directory and provides summary information about the code files it contains. It can help you gain insights into your codebase's structure, naming conventions, and content types.
+
+![Example Image](./example-output.png)
+
+
+## Features
+
+- Analyzes the specified directory recursively
+- Provides summary information about file name cases and content types
+- Supports filtering by file extensions and excluding specific directories/files
+- Customizable through command-line options
+
+## Installation
+
+You can install Codebase Analyzer globally using NPM:
+
+```bash
+npm install -g analyze-codebase 
+```
+
+## Usage
+
+To analyze a directory, use the analyze command followed by the directory path. Here's an example:
+
+```bash
+analyze-codebase analyze ./src
+```
+
+## Options
+
+- -f, --framework <framework>: Specify the framework used in the codebase.
+- -e, --extensions <extensions...>: Specify the file extensions to include in the analysis. You can provide multiple extensions separated by spaces. Example: -e .js .ts.
+
+- -e, --exclude <exclude...>: Specify directories or files to exclude from the analysis. You can provide multiple paths separated by spaces. Example: -e node_modules dist.
+
+- --checkFileNames [checkFileNames]: Check file names. Default: true.
+
+- --checkFileContent [checkFileContent]: Check file content. Default: true.
+
+## Examples
+
+Analyze a directory with default options:
+
+```bash
+analyze-codebase analyze ./src
+```
+
+Analyze a directory with a specified framework and file extensions:
+
+```bash
+analyze-codebase analyze ./src -f react --extensions .js .jsx .ts .tsx
+```
+
+Exclude specific directories from the analysis:
+
+```bash
+analyze-codebase analyze ./src --exclude node_modules dist
+```
+
+Analyze only file names
+
+```bash
+analyze-codebase analyze ./src --exclude node_modules dist --checkFileContent=false
+```
+
+Analyze only file content
+
+```bash
+analyze-codebase analyze ./src --exclude node_modules dist --checkFileNames=false
+```
+
+## Contribution
+
+We welcome contributions to enhance the functionality and features of Codebase Analyzer. To contribute to the project, please follow these steps:
+
+Fork the repository by clicking on the "Fork" button at the top right corner of this page.
+
+Clone the forked repository to your local machine:
+
+```bash
+git clone https://github.com/your-username/analyze-codebase.git
+```
+
+Create a new branch for your feature or bug fix:
+
+```bash
+git checkout -b feature/your-feature-name
+```
+
+or 
+
+
+```bash
+git checkout -b bugfix/your-bug-fix
+```
+
+Make your modifications and additions to the codebase.
+
+Test your changes thoroughly to ensure they do not introduce any issues.
+
+Commit your changes with a descriptive commit message:
+
+```bash
+git commit -m "Add your commit message here"
+```
+
+Push your changes to your forked repository:
+
+```bash
+git push origin feature/your-feature-name
+```
+or
+
+```bash
+git push origin bugfix/your-bug-fix
+```
+
+Open a pull request (PR) from your forked repository to the original repository. Provide a clear and concise description of your changes in the PR.
+
+Wait for the maintainers to review your PR. They may provide feedback or request additional changes.
+
+Once your PR is approved, it will be merged into the main branch, and your contributions will become a part of the Codebase Analyzer project.
+
+Please ensure that you adhere to our code of conduct and follow the guidelines provided in the CONTRIBUTING.md file for a smooth and collaborative contribution process.
+
+Thank you for your interest in improving Codebase Analyzer! Your contributions are highly appreciated.
+
+## License
+This project is licensed under the MIT License.

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "commonjs",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "sourceMap": false,
+    "declaration": true
+  },
+  "include": [
+    "src",
+    "extensions"
+  ]
+}