code-quality-lib 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NoonCore
+
+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/README.md

@@ -0,0 +1,394 @@
+# Code Quality Library
+
+[![npm version](https://badge.fury.io/js/code-quality-lib.svg)](https://badge.fury.io/js/code-quality-lib)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D14.0.0-brightgreen)](https://nodejs.org/)
+
+> A configurable code quality checker library for Node.js projects that supports TypeScript, ESLint, Prettier, Knip, and Snyk with beautiful terminal output.
+
+## Features
+
+- **Multi-Package Manager Support**: Auto-detects and works with bun, pnpm, yarn, and npm
+- **Configurable**: Customize which tools to run and their commands
+- **Beautiful Output**: Colorized terminal output with clear status indicators  
+- **Environment Support**: Automatically loads `.env` files
+- **Snyk Integration**: Handles Snyk authentication gracefully
+- **TypeScript Support**: Full TypeScript definitions included
+- **CLI & Library**: Can be used as both command-line tool and library
+- **Extensible**: Easy to add custom tools and checks
+- **Detailed Reporting**: Clear error counts and status messages
+
+## Installation
+
+### npm
+```bash
+# Install as development dependency (recommended)
+npm install -D code-quality-lib
+
+# Install globally for CLI usage
+npm install -g code-quality-lib
+
+# Install from GitHub (development)
+npm install -D https://github.com/NoonCore/code-quality-lib.git
+```
+
+### bun (recommended - faster)
+```bash
+# Install as development dependency (recommended)
+bun add -D code-quality-lib
+
+# Install globally for CLI usage
+bun add -g code-quality-lib
+
+# Install from GitHub (development)
+bun add -D https://github.com/NoonCore/code-quality-lib.git
+```
+
+### pnpm
+```bash
+# Install as development dependency (recommended)
+pnpm add -D code-quality-lib
+
+# Install globally for CLI usage
+pnpm add -g code-quality-lib
+
+# Install from GitHub (development)
+pnpm add -D https://github.com/NoonCore/code-quality-lib.git
+```
+
+### yarn
+```bash
+# Install as development dependency (recommended)
+yarn add -D code-quality-lib
+
+# Install globally for CLI usage
+yarn global add code-quality-lib
+
+# Install from GitHub (development)
+yarn add -D https://github.com/NoonCore/code-quality-lib.git
+```
+
+## Usage
+
+### As a CLI Tool
+
+```bash
+# Run all quality checks
+code-quality
+
+# Or use with npx
+npx code-quality-lib
+```
+
+### As a Library
+
+```javascript
+const { CodeQualityChecker } = require('code-quality-lib');
+
+// Use default configuration
+const checker = new CodeQualityChecker();
+checker.run().then(result => {
+  console.log(result.success ? '✅ All checks passed!' : '❌ Some checks failed');
+});
+```
+
+## Configuration
+
+### Default Tools
+
+The library runs these tools by default:
+- **TypeScript** - Type checking and compilation
+- **ESLint** - Code linting and style checking  
+- **Prettier** - Code formatting validation
+- **Knip** - Dead code detection and unused exports
+- **Snyk** - Security vulnerability scanning
+
+### Custom Configuration
+
+```javascript
+const customChecker = new CodeQualityChecker({
+  // Force specific package manager
+  packageManager: 'pnpm', // 'bun' | 'pnpm' | 'yarn' | 'npm'
+  
+  // Only run specific tools
+  tools: ['TypeScript', 'ESLint'],
+  
+  // Custom commands for each tool
+  commands: {
+    TypeScript: 'tsc --noEmit',
+    ESLint: 'eslint src/ --ext .ts,.tsx',
+    Prettier: 'prettier --check "src/**/*.{ts,tsx}"'
+  },
+  
+  // Custom descriptions
+  descriptions: {
+    TypeScript: 'TypeScript type checking',
+    ESLint: 'ESLint code analysis'
+  },
+  
+  // Disable .env loading
+  loadEnv: false
+});
+```
+
+### Package Manager Detection
+
+The library automatically detects your package manager in this order:
+1. **Lock files**: `bun.lock`, `pnpm-lock.yaml`, `yarn.lock`, `package-lock.json`
+2. **Available commands**: Checks if `bun`, `pnpm`, `yarn` are installed
+3. **Fallback**: Uses `npm` if nothing else is found
+
+You can also override the detection:
+```javascript
+const checker = new CodeQualityChecker({
+  packageManager: 'yarn' // Force yarn usage
+});
+```
+
+### Environment-Specific Configuration
+
+```javascript
+const isCI = process.env.CI === 'true';
+const ciChecker = new CodeQualityChecker({
+  tools: isCI 
+    ? ['TypeScript', 'ESLint'] 
+    : ['TypeScript', 'ESLint', 'Prettier', 'Knip', 'Snyk'],
+  loadEnv: !isCI
+});
+```
+
+## Integration with Existing Projects
+
+### Replace Existing Scripts
+
+**Before:**
+```json
+{
+  "scripts": {
+    "quality": "node scripts/quality-check.js"
+  }
+}
+```
+
+**After:**
+```json
+{
+  "scripts": {
+    "quality": "code-quality"
+  }
+}
+```
+
+### Programmatic Usage
+
+```javascript
+// In your build script
+const { CodeQualityChecker } = require('code-quality-lib');
+
+async function buildWithQualityCheck() {
+  const checker = new CodeQualityChecker({
+    tools: ['TypeScript', 'ESLint']
+  });
+  
+  const result = await checker.run();
+  if (!result.success) {
+    console.error('❌ Quality checks failed!');
+    process.exit(1);
+  }
+  
+  // Continue with build...
+  console.log('✅ Quality checks passed, building...');
+}
+
+buildWithQualityCheck();
+```
+
+## Output Example
+
+```
+🔍 Professional Code Quality Check
+
+──────────────────────────────────────────────────
+📦 Using bun package manager
+Checking Snyk authentication...
+Running TypeScript compilation...
+Running ESLint validation...
+Running Prettier formatting...
+Running Dead code detection...
+Running Security vulnerability scan...
+
+✅ TypeScript: 0 errors
+✅ ESLint: 0 errors, 0 warnings  
+✅ Prettier: All files formatted
+✅ Knip: No critical errors
+✅ Snyk: No vulnerabilities
+──────────────────────────────────────────────────
+
+🎉 All quality checks passed! Code is ready for production.
+```
+
+## API Reference
+
+### CodeQualityChecker
+
+#### Constructor
+```javascript
+new CodeQualityChecker(options)
+```
+
+#### Options
+- `loadEnv` (boolean): Load environment variables from `.env` file
+- `tools` (string[]): Array of tool names to run
+- `commands` (Record<string, string>): Custom commands for each tool
+- `descriptions` (Record<string, string>): Descriptions shown during execution
+- `packageManager` ('bun' | 'pnpm' | 'yarn' | 'npm'): Force specific package manager (auto-detected if not specified)
+
+#### Methods
+- `run()`: Promise<QualityCheckResult> - Run all configured checks
+- `runCommand(command, description)`: CommandResult - Execute a single command
+- `formatOutput(tool, result)`: string - Format output for a tool
+- `checkSnykToken()`: boolean - Check Snyk authentication status
+
+### Types
+
+```typescript
+interface CodeQualityOptions {
+  loadEnv?: boolean;
+  tools?: string[];
+  commands?: Record<string, string>;
+  descriptions?: Record<string, string>;
+  packageManager?: 'bun' | 'pnpm' | 'yarn' | 'npm';
+}
+
+interface CommandResult {
+  success: boolean;
+  output: string;
+}
+
+interface QualityCheckResult {
+  success: boolean;
+  message: string;
+}
+```
+
+## Requirements
+
+- **Node.js** >= 14.0.0
+- **Package Manager**: bun, pnpm, yarn, or npm (auto-detected)
+- **Quality Tools** (install only what you need):
+  - **TypeScript** - `npm install -D typescript` or `bun add -D typescript` or `pnpm add -D typescript` or `yarn add -D typescript`
+  - **ESLint** - `npm install -D eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin` or `bun add -D eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin`
+  - **Prettier** - `npm install -D prettier eslint-config-prettier` or `bun add -D prettier eslint-config-prettier`
+  - **Knip** - `npm install -D knip` or `bun add -D knip`
+  - **Snyk** - `npm install -D snyk` or `bun add -D snyk`
+
+### Quick Setup
+
+#### npm
+```bash
+# Install all quality tools
+npm install -D typescript eslint prettier knip snyk
+
+# Minimal setup
+npm install -D typescript eslint prettier
+```
+
+#### bun (recommended - faster)
+```bash
+# Install all quality tools
+bun add -D typescript eslint prettier knip snyk
+
+# Minimal setup
+bun add -D typescript eslint prettier
+```
+
+#### pnpm
+```bash
+# Install all quality tools
+pnpm add -D typescript eslint prettier knip snyk
+
+# Minimal setup
+pnpm add -D typescript eslint prettier
+```
+
+#### yarn
+```bash
+# Install all quality tools
+yarn add -D typescript eslint prettier knip snyk
+
+# Minimal setup
+yarn add -D typescript eslint prettier
+```
+
+**Note**: The library automatically skips tools that aren't installed, so you can start with just the tools you need and add more later.
+
+## Framework Compatibility
+
+This library is framework-agnostic and works with:
+
+- **Next.js** (all versions)
+- **React** (Create React App, Vite, etc.)
+- **Vue.js** (Vue CLI, Nuxt, Vite)
+- **Angular** (Angular CLI)
+- **Node.js** (Express, Koa, etc.)
+- **TypeScript** projects
+- **Plain JavaScript** projects
+
+## Examples
+
+### Next.js Project
+```javascript
+const { CodeQualityChecker } = require('code-quality-lib');
+
+const nextJSChecker = new CodeQualityChecker({
+  commands: {
+    TypeScript: 'tsc --noEmit',
+    ESLint: 'next lint',
+    Prettier: 'prettier --check .',
+    Knip: 'knip',
+    Snyk: 'snyk test'
+  }
+});
+```
+
+### Vue.js Project
+```javascript
+const vueChecker = new CodeQualityChecker({
+  commands: {
+    TypeScript: 'vue-tsc --noEmit',
+    ESLint: 'eslint .ext .vue,.js,.ts',
+    Prettier: 'prettier --check .'
+  }
+});
+```
+
+### Express.js Project
+```javascript
+const expressChecker = new CodeQualityChecker({
+  tools: ['TypeScript', 'ESLint'],
+  commands: {
+    TypeScript: 'tsc --noEmit',
+    ESLint: 'eslint src/'
+  }
+});
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Built for modern JavaScript/TypeScript development workflows
+- Inspired by the need for unified quality checking across projects
+- Designed with developer experience and productivity in mind

package/index.d.ts

@@ -0,0 +1,31 @@
+export interface CodeQualityOptions {
+  loadEnv?: boolean;
+  tools?: string[];
+  commands?: Record<string, string>;
+  descriptions?: Record<string, string>;
+  packageManager?: 'bun' | 'pnpm' | 'yarn' | 'npm';
+}
+
+export interface CommandResult {
+  success: boolean;
+  output: string;
+}
+
+export interface QualityCheckResult {
+  success: boolean;
+  message: string;
+}
+
+export class CodeQualityChecker {
+  constructor(options?: CodeQualityOptions);
+  
+  runCommand(command: string, description: string): CommandResult;
+  
+  formatOutput(tool: string, result: CommandResult): string;
+  
+  checkSnykToken(): boolean;
+  
+  run(): Promise<QualityCheckResult>;
+}
+
+export function runQualityCheck(options?: CodeQualityOptions): Promise<QualityCheckResult>;

package/index.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+// Load environment variables from .env file
+function loadEnvFile() {
+  try {
+    const fs = require('fs');
+    const envPath = path.join(process.cwd(), '.env');
+
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, 'utf8');
+      const lines = envContent.split('\n');
+
+      lines.forEach((line) => {
+        // Skip comments and empty lines
+        if (line.trim() && !line.trim().startsWith('#')) {
+          const [key, ...valueParts] = line.split('=');
+          if (key && valueParts.length > 0) {
+            const value = valueParts.join('=').trim();
+            process.env[key.trim()] = value;
+          }
+        }
+      });
+
+      console.log('✅ Loaded environment variables from .env');
+    }
+  } catch (error) {
+    // Continue without .env if file doesn't exist or can't be read
+  }
+}
+
+// Colors for beautiful output
+const colors = {
+  success: '\x1b[32m\x1b[1m✅\x1b[0m',
+  error: '\x1b[31m\x1b[1m❌\x1b[0m',
+  warning: '\x1b[33m\x1b[1m⚠️\x1b[0m',
+  info: '\x1b[34m\x1b[1mℹ️\x1b[0m',
+  header: (text) => `\x1b[36m\x1b[1m${text}\x1b[0m`,
+  text: (text) => `\x1b[37m${text}\x1b[0m`,
+  dim: (text) => `\x1b[90m${text}\x1b[0m`,
+};
+
+function runCommand(command, description) {
+  try {
+    console.log(colors.dim(`Running ${description}...`));
+    const result = execSync(command, { encoding: 'utf8', stdio: 'pipe' });
+    return { success: true, output: result.trim() };
+  } catch (error) {
+    return { success: false, output: error.stdout || error.message };
+  }
+}
+
+function formatOutput(tool, result) {
+  if (tool === 'TypeScript') {
+    if (result.success) {
+      return `${colors.success} TypeScript: ${colors.text('0 errors')}`;
+    } else {
+      const errors = (result.output.match(/error/g) || []).length;
+      return `${colors.error} TypeScript: ${colors.text(`${errors} errors`)}`;
+    }
+  }
+
+  if (tool === 'ESLint') {
+    if (result.success) {
+      return `${colors.success} ESLint: ${colors.text('0 errors, 0 warnings')}`;
+    } else {
+      const errors = (result.output.match(/error/g) || []).length;
+      const warnings = (result.output.match(/warning/g) || []).length;
+      return `${colors.error} ESLint: ${colors.text(`${errors} errors, ${warnings} warnings`)}`;
+    }
+  }
+
+  if (tool === 'Prettier') {
+    if (result.success) {
+      return `${colors.success} Prettier: ${colors.text('All files formatted')}`;
+    } else {
+      return `${colors.error} Prettier: ${colors.text('Formatting issues found')}`;
+    }
+  }
+
+  if (tool === 'Knip') {
+    if (result.success && result.output.includes('✅ No Knip errors found')) {
+      return `${colors.success} Knip: ${colors.text('No critical errors')}`;
+    } else {
+      const errors = (result.output.match(/error/g) || []).length;
+      return `${colors.error} Knip: ${colors.text(`${errors} critical errors`)}`;
+    }
+  }
+
+    if (tool === 'Snyk') {
+      if (
+        result.output.includes('Authentication required - run')
+      ) {
+        return `${colors.warning} Snyk: ${colors.text('Authentication required')}`;
+      } else if (
+        result.success &&
+        result.output.includes('no vulnerable paths found')
+      ) {
+        return `${colors.success} Snyk: ${colors.text('No vulnerabilities')}`;
+      } else if (
+        result.output.includes('Authentication error') ||
+        result.output.includes('SNYK-0005')
+      ) {
+        return `${colors.warning} Snyk: ${colors.text('Authentication required')}`;
+      } else if (result.success) {
+        const vulnerabilities = (result.output.match(/vulnerabilities/g) || [])
+          .length;
+        return `${colors.success} Snyk: ${colors.text(`${vulnerabilities} vulnerabilities found`)}`;
+      } else {
+        return `${colors.error} Snyk: ${colors.text('Scan failed')}`;
+      }
+    }
+
+  return `${colors.error} ${tool}: ${colors.text('Unknown status')}`;
+}
+
+function checkSnykToken() {
+  try {
+    console.log(colors.dim('Checking Snyk authentication...'));
+
+    // Check if SNYK_TOKEN is available in environment
+    const snykToken = process.env.SNYK_TOKEN;
+    if (snykToken && snykToken.startsWith('snyk_')) {
+      console.log(colors.dim('✅ SNYK_TOKEN found in environment'));
+      return true;
+    }
+
+    // Fallback to CLI authentication check
+    const packageManager = detectPackageManager();
+    const execCommand = getExecCommand(packageManager);
+    const result = execSync(`${execCommand} snyk whoami --experimental`, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+    // Check if authentication was successful (returns username)
+    return (
+      result.trim().length > 0 &&
+      !result.includes('Authentication error') &&
+      !result.includes('SNYK-0005')
+    );
+  } catch (error) {
+    return false;
+  }
+}
+
+// Detect package manager
+function detectPackageManager() {
+  try {
+    // Check for lock files
+    const fs = require('fs');
+    
+    if (fs.existsSync('bun.lock')) {
+      return 'bun';
+    }
+    if (fs.existsSync('pnpm-lock.yaml')) {
+      return 'pnpm';
+    }
+    if (fs.existsSync('yarn.lock')) {
+      return 'yarn';
+    }
+    if (fs.existsSync('package-lock.json')) {
+      return 'npm';
+    }
+    
+    // Fallback to checking if commands are available
+    try {
+      execSync('which bun', { stdio: 'ignore' });
+      return 'bun';
+    } catch {}
+    
+    try {
+      execSync('which pnpm', { stdio: 'ignore' });
+      return 'pnpm';
+    } catch {}
+    
+    try {
+      execSync('which yarn', { stdio: 'ignore' });
+      return 'yarn';
+    } catch {}
+    
+    return 'npm'; // Default fallback
+  } catch (error) {
+    return 'npm'; // Default fallback
+  }
+}
+
+// Get package manager run command
+function getRunCommand(packageManager) {
+  switch (packageManager) {
+    case 'bun': return 'bun run';
+    case 'pnpm': return 'pnpm run';
+    case 'yarn': return 'yarn';
+    case 'npm': return 'npm run';
+    default: return 'npm run';
+  }
+}
+
+// Get package manager exec command
+function getExecCommand(packageManager) {
+  switch (packageManager) {
+    case 'bun': return 'bunx';
+    case 'pnpm': return 'pnpm dlx';
+    case 'yarn': return 'yarn dlx';
+    case 'npm': return 'npx';
+    default: return 'npx';
+  }
+}
+
+// Main class for the library
+class CodeQualityChecker {
+  constructor(options = {}) {
+    const packageManager = options.packageManager || detectPackageManager();
+    const runCommand = getRunCommand(packageManager);
+    const execCommand = getExecCommand(packageManager);
+    
+    this.options = {
+      loadEnv: true,
+      tools: ['TypeScript', 'ESLint', 'Prettier', 'Knip', 'Snyk'],
+      commands: {
+        TypeScript: `${runCommand} type:check`,
+        ESLint: `${runCommand} lint:check`,
+        Prettier: `${runCommand} format:check`,
+        Knip: `${runCommand} knip:error`,
+        Snyk: `${runCommand} snyk`
+      },
+      descriptions: {
+        TypeScript: 'TypeScript compilation',
+        ESLint: 'ESLint validation',
+        Prettier: 'Prettier formatting',
+        Knip: 'Dead code detection',
+        Snyk: 'Security vulnerability scan'
+      },
+      packageManager,
+      ...options
+    };
+    
+    if (this.options.loadEnv) {
+      loadEnvFile();
+    }
+  }
+
+  runCommand(command, description) {
+    return runCommand(command, description);
+  }
+
+  formatOutput(tool, result) {
+    return formatOutput(tool, result);
+  }
+
+  checkSnykToken() {
+    return checkSnykToken();
+  }
+
+  async run() {
+    console.log(colors.header('\n🔍 Professional Code Quality Check\n'));
+    console.log(colors.dim('─'.repeat(50)));
+    
+    // Show detected package manager
+    console.log(colors.dim(`📦 Using ${this.options.packageManager} package manager`));
+
+    // Check Snyk authentication first
+    const snykAuthenticated = this.checkSnykToken();
+
+    const results = this.options.tools.map(tool => ({
+      tool,
+      command: tool === 'Snyk' && !snykAuthenticated
+        ? `echo "Authentication required - add SNYK_TOKEN to .env or run ${getExecCommand(this.options.packageManager)} snyk auth"`
+        : this.options.commands[tool],
+      description: this.options.descriptions[tool]
+    }));
+
+    let allPassed = true;
+    const outputs = [];
+
+    for (const { tool, command, description } of results) {
+      const result = this.runCommand(command, description);
+      const output = this.formatOutput(tool, result);
+      outputs.push(output);
+      if (!result.success) {
+        allPassed = false;
+      }
+    }
+
+    console.log('\n');
+    outputs.forEach((output) => console.log(output));
+
+    console.log(colors.dim('─'.repeat(50)));
+
+    if (allPassed) {
+      console.log(
+        '\n🎉 All quality checks passed! Code is ready for production.\n'
+      );
+      return { success: true, message: 'All checks passed' };
+    } else {
+      console.log(
+        '\n❌ Some quality checks failed. Please fix the issues above.\n'
+      );
+      return { success: false, message: 'Some checks failed' };
+    }
+  }
+}
+
+// Export both the class and a simple function
+module.exports = { CodeQualityChecker };
+
+// If run directly, execute with default options
+if (require.main === module) {
+  const checker = new CodeQualityChecker();
+  checker.run().then(result => {
+    process.exit(result.success ? 0 : 1);
+  });
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "code-quality-lib",
+  "version": "1.0.0",
+  "description": "A configurable code quality checker library for Node.js projects",
+  "main": "index.js",
+  "bin": {
+    "code-quality": "index.js"
+  },
+  "scripts": {
+    "test": "node test/basic.test.js",
+    "test:ci": "node test/basic.test.js",
+    "start": "node index.js",
+    "lint": "echo 'Linting not configured yet'",
+    "format": "echo 'Formatting not configured yet'",
+    "build": "echo 'No build step required'",
+    "prepublishOnly": "echo 'Skipping tests for publishing'"
+  },
+  "keywords": [
+    "code-quality",
+    "eslint",
+    "prettier",
+    "typescript",
+    "snyk",
+    "knip",
+    "quality-check"
+  ],
+  "author": "",
+  "license": "MIT",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NoonCore/code-quality-lib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/NoonCore/code-quality-lib/issues"
+  },
+  "homepage": "https://github.com/NoonCore/code-quality-lib#readme"
+}