vg-coder-cli 1.0.17 → 2.0.0

package/vg/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@vg/source",
+  "version": "0.0.0",
+  "license": "MIT",
+  "scripts": {},
+  "private": true,
+  "devDependencies": {
+    "@angular-devkit/core": "~20.3.0",
+    "@angular-devkit/schematics": "~20.3.0",
+    "@angular/build": "~20.3.0",
+    "@angular/cli": "~20.3.0",
+    "@angular/compiler-cli": "~20.3.0",
+    "@angular/language-service": "~20.3.0",
+    "@eslint/js": "^9.8.0",
+    "@nestjs/schematics": "^11.0.0",
+    "@nestjs/testing": "^11.0.0",
+    "@nx/angular": "^22.1.3",
+    "@nx/eslint": "22.1.3",
+    "@nx/eslint-plugin": "22.1.3",
+    "@nx/jest": "22.1.3",
+    "@nx/js": "^22.1.3",
+    "@nx/nest": "^22.1.3",
+    "@nx/node": "22.1.3",
+    "@nx/web": "22.1.3",
+    "@nx/webpack": "22.1.3",
+    "@nx/workspace": "22.1.3",
+    "@schematics/angular": "~20.3.0",
+    "@swc-node/register": "~1.9.1",
+    "@swc/core": "~1.5.7",
+    "@swc/helpers": "~0.5.11",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.12",
+    "@types/node": "20.19.9",
+    "@types/supertest": "^6.0.3",
+    "@typescript-eslint/utils": "^8.40.0",
+    "angular-eslint": "^20.3.0",
+    "eslint": "^9.8.0",
+    "eslint-config-prettier": "^10.0.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jest-environment-node": "^29.7.0",
+    "jest-preset-angular": "~14.6.1",
+    "jest-util": "^29.7.0",
+    "jsonc-eslint-parser": "^2.1.0",
+    "nx": "22.1.3",
+    "prettier": "^2.6.2",
+    "supertest": "^7.1.4",
+    "ts-jest": "^29.1.0",
+    "ts-node": "10.9.1",
+    "tslib": "^2.3.0",
+    "typescript": "~5.9.2",
+    "typescript-eslint": "^8.40.0",
+    "webpack-cli": "^5.1.4"
+  },
+  "dependencies": {
+    "@angular/common": "~20.3.0",
+    "@angular/compiler": "~20.3.0",
+    "@angular/core": "~20.3.0",
+    "@angular/forms": "~20.3.0",
+    "@angular/platform-browser": "~20.3.0",
+    "@angular/platform-browser-dynamic": "~20.3.0",
+    "@angular/router": "~20.3.0",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "axios": "^1.6.0",
+    "directory-tree": "^3.5.2",
+    "fs-extra": "^11.3.2",
+    "ignore": "^7.0.5",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.8.0",
+    "tiktoken": "^1.0.22",
+    "zone.js": "~0.15.0"
+  }
+}

package/vg/packages/client/data-access/README.md

@@ -0,0 +1,7 @@
+# data-access
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test data-access` to execute the unit tests.

package/vg/packages/client/data-access/jest.config.ts

@@ -0,0 +1,21 @@
+export default {
+  displayName: 'data-access',
+  preset: '../../../jest.preset.js',
+  setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+  coverageDirectory: '../../../coverage/packages/client/data-access',
+  transform: {
+    '^.+\\.(ts|mjs|js|html)$': [
+      'jest-preset-angular',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+        stringifyContentPathRegex: '\\.(html|svg)$',
+      },
+    ],
+  },
+  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+  snapshotSerializers: [
+    'jest-preset-angular/build/serializers/no-ng-attributes',
+    'jest-preset-angular/build/serializers/ng-snapshot',
+    'jest-preset-angular/build/serializers/html-comment',
+  ],
+};

package/vg/packages/client/data-access/project.json

@@ -0,0 +1,21 @@
+{
+  "name": "data-access",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/client/data-access/src",
+  "prefix": "lib",
+  "projectType": "library",
+  "tags": ["scope:client", "type:lib"],
+  "targets": {
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "packages/client/data-access/jest.config.ts",
+        "tsConfig": "packages/client/data-access/tsconfig.spec.json"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

package/vg/packages/client/data-access/src/index.ts

@@ -0,0 +1 @@
+export * from './lib/data-access/data-access';

package/vg/packages/client/data-access/src/lib/data-access/data-access.html

@@ -0,0 +1 @@
+<p>DataAccess works!</p>

package/vg/packages/client/data-access/src/lib/data-access/data-access.ts

@@ -0,0 +1,9 @@
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'lib-data-access',
+  imports: [],
+  templateUrl: './data-access.html',
+  styleUrl: './data-access.scss',
+})
+export class DataAccess {}

package/vg/packages/client/data-access/src/test-setup.ts

@@ -0,0 +1,6 @@
+import { setupZoneTestEnv } from 'jest-preset-angular/setup-env/zone';
+
+setupZoneTestEnv({
+  errorOnUnknownElements: true,
+  errorOnUnknownProperties: true,
+});

package/vg/packages/core/README.md

@@ -0,0 +1,11 @@
+# core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build core` to build the library.
+
+## Running unit tests
+
+Run `nx test core` to execute the unit tests via [Jest](https://jestjs.io).

package/vg/packages/core/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'core',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/packages/core',
+};

package/vg/packages/core/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@vg/core",
+  "version": "0.0.1",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/vg/packages/core/project.json

@@ -0,0 +1,26 @@
+{
+  "name": "core",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/core/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/core",
+        "main": "packages/core/src/index.ts",
+        "tsConfig": "packages/core/tsconfig.lib.json",
+        "assets": ["packages/core/*.md"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "packages/core/jest.config.ts"
+      }
+    }
+  }
+}

package/vg/packages/core/src/index.ts

@@ -0,0 +1,6 @@
+export * from './lib/core';
+export * from './lib/detectors/project-detector';
+export * from './lib/scanner/file-scanner';
+export * from './lib/tokenizer/token-manager';
+export * from './lib/utils/bash-executor';
+export * from './lib/ignore/ignore-manager';

package/vg/packages/core/src/lib/core.ts

@@ -0,0 +1,3 @@
+export function core(): string {
+  return 'core';
+}

package/vg/packages/core/src/lib/detectors/project-detector.ts

@@ -0,0 +1,343 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+export interface ProjectTypeInfo {
+    detected: boolean;
+    confidence?: 'high' | 'medium' | 'low';
+    version?: string;
+    buildTool?: string;
+    indicators?: Record<string, any>;
+}
+
+export interface DetectionResult {
+    detected: Record<string, ProjectTypeInfo>;
+    primary: string;
+    all: Record<string, ProjectTypeInfo>;
+}
+
+/**
+ * Detect project type based on configuration files
+ */
+export class ProjectDetector {
+    constructor(private projectPath: string) { }
+
+    /**
+     * Detect all possible project types
+     */
+    async detectAll(): Promise<DetectionResult> {
+        const results: Record<string, ProjectTypeInfo> = {
+            angular: await this.detectAngular(),
+            springBoot: await this.detectSpringBoot(),
+            react: await this.detectReact(),
+            vue: await this.detectVue(),
+            nodejs: await this.detectNodeJS(),
+            java: await this.detectJava(),
+            python: await this.detectPython(),
+            dotnet: await this.detectDotNet()
+        };
+
+        // Filter detected types
+        const detected = Object.entries(results)
+            .filter(([_, info]) => info.detected)
+            .reduce((acc, [type, info]) => {
+                acc[type] = info;
+                return acc;
+            }, {} as Record<string, ProjectTypeInfo>);
+
+        return {
+            detected,
+            primary: this.determinePrimaryType(detected),
+            all: results
+        };
+    }
+
+    /**
+     * Detect Angular project
+     */
+    async detectAngular(): Promise<ProjectTypeInfo> {
+        try {
+            const packageJsonPath = path.join(this.projectPath, 'package.json');
+            const angularJsonPath = path.join(this.projectPath, 'angular.json');
+
+            if (await fs.pathExists(packageJsonPath)) {
+                const packageJson = await fs.readJson(packageJsonPath);
+                const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+                const hasAngularCore = deps['@angular/core'];
+                const hasAngularCli = deps['@angular/cli'];
+                const hasAngularJson = await fs.pathExists(angularJsonPath);
+
+                if (hasAngularCore || hasAngularCli || hasAngularJson) {
+                    return {
+                        detected: true,
+                        confidence: hasAngularCore && hasAngularJson ? 'high' : 'medium',
+                        version: hasAngularCore || 'unknown',
+                        indicators: {
+                            packageJson: !!hasAngularCore || !!hasAngularCli,
+                            angularJson: hasAngularJson,
+                            dependencies: Object.keys(deps).filter(dep => dep.startsWith('@angular/'))
+                        }
+                    };
+                }
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Detect Spring Boot project
+     */
+    async detectSpringBoot(): Promise<ProjectTypeInfo> {
+        try {
+            const pomPath = path.join(this.projectPath, 'pom.xml');
+            const gradlePath = path.join(this.projectPath, 'build.gradle');
+            const gradleKtsPath = path.join(this.projectPath, 'build.gradle.kts');
+
+            // Check Maven (pom.xml)
+            if (await fs.pathExists(pomPath)) {
+                const pomContent = await fs.readFile(pomPath, 'utf8');
+                if (pomContent.includes('spring-boot-starter') || pomContent.includes('org.springframework.boot')) {
+                    return {
+                        detected: true,
+                        confidence: 'high',
+                        buildTool: 'maven',
+                        indicators: {
+                            pomXml: true,
+                            springBootStarter: pomContent.includes('spring-boot-starter')
+                        }
+                    };
+                }
+            }
+
+            // Check Gradle
+            for (const gradleFile of [gradlePath, gradleKtsPath]) {
+                if (await fs.pathExists(gradleFile)) {
+                    const gradleContent = await fs.readFile(gradleFile, 'utf8');
+                    if (gradleContent.includes('spring-boot') || gradleContent.includes('org.springframework.boot')) {
+                        return {
+                            detected: true,
+                            confidence: 'high',
+                            buildTool: gradleFile.endsWith('.kts') ? 'gradle-kotlin' : 'gradle',
+                            indicators: {
+                                buildGradle: true,
+                                springBootPlugin: gradleContent.includes('org.springframework.boot')
+                            }
+                        };
+                    }
+                }
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Detect React project
+     */
+    async detectReact(): Promise<ProjectTypeInfo> {
+        try {
+            const packageJsonPath = path.join(this.projectPath, 'package.json');
+            if (await fs.pathExists(packageJsonPath)) {
+                const packageJson = await fs.readJson(packageJsonPath);
+                const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+                if (deps.react) {
+                    return {
+                        detected: true,
+                        confidence: 'high',
+                        version: deps.react,
+                        indicators: {
+                            react: true,
+                            reactDom: !!deps['react-dom'],
+                            nextJs: !!deps.next,
+                            createReactApp: !!deps['react-scripts']
+                        }
+                    };
+                }
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Detect Vue project
+     */
+    async detectVue(): Promise<ProjectTypeInfo> {
+        try {
+            const packageJsonPath = path.join(this.projectPath, 'package.json');
+            if (await fs.pathExists(packageJsonPath)) {
+                const packageJson = await fs.readJson(packageJsonPath);
+                const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+                if (deps.vue) {
+                    return {
+                        detected: true,
+                        confidence: 'high',
+                        version: deps.vue,
+                        indicators: {
+                            vue: true,
+                            vueRouter: !!deps['vue-router'],
+                            vuex: !!deps.vuex,
+                            nuxt: !!deps.nuxt
+                        }
+                    };
+                }
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Detect Node.js project
+     */
+    async detectNodeJS(): Promise<ProjectTypeInfo> {
+        try {
+            const packageJsonPath = path.join(this.projectPath, 'package.json');
+            const exists = await fs.pathExists(packageJsonPath);
+            return {
+                detected: exists,
+                confidence: 'high',
+                indicators: {
+                    packageJson: exists
+                }
+            };
+        } catch (error) {
+            return { detected: false };
+        }
+    }
+
+    /**
+     * Detect Java project
+     */
+    async detectJava(): Promise<ProjectTypeInfo> {
+        try {
+            const pomPath = path.join(this.projectPath, 'pom.xml');
+            const gradlePath = path.join(this.projectPath, 'build.gradle');
+            const gradleKtsPath = path.join(this.projectPath, 'build.gradle.kts');
+
+            const hasPom = await fs.pathExists(pomPath);
+            const hasGradle = await fs.pathExists(gradlePath) || await fs.pathExists(gradleKtsPath);
+
+            if (hasPom || hasGradle) {
+                return {
+                    detected: true,
+                    confidence: 'high',
+                    buildTool: hasPom ? 'maven' : 'gradle',
+                    indicators: {
+                        maven: hasPom,
+                        gradle: hasGradle
+                    }
+                };
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Detect Python project
+     */
+    async detectPython(): Promise<ProjectTypeInfo> {
+        try {
+            const requirementsPath = path.join(this.projectPath, 'requirements.txt');
+            const pipfilePath = path.join(this.projectPath, 'Pipfile');
+            const pyprojectPath = path.join(this.projectPath, 'pyproject.toml');
+            const setupPyPath = path.join(this.projectPath, 'setup.py');
+
+            const hasRequirements = await fs.pathExists(requirementsPath);
+            const hasPipfile = await fs.pathExists(pipfilePath);
+            const hasPyproject = await fs.pathExists(pyprojectPath);
+            const hasSetupPy = await fs.pathExists(setupPyPath);
+
+            if (hasRequirements || hasPipfile || hasPyproject || hasSetupPy) {
+                return {
+                    detected: true,
+                    confidence: 'high',
+                    indicators: {
+                        requirements: hasRequirements,
+                        pipfile: hasPipfile,
+                        pyproject: hasPyproject,
+                        setupPy: hasSetupPy
+                    }
+                };
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Detect .NET project
+     */
+    async detectDotNet(): Promise<ProjectTypeInfo> {
+        try {
+            const csprojFiles = await this.findFilesByExtension('.csproj');
+            const vbprojFiles = await this.findFilesByExtension('.vbproj');
+            const fsprojFiles = await this.findFilesByExtension('.fsproj');
+            const slnFiles = await this.findFilesByExtension('.sln');
+
+            const hasProjectFiles = csprojFiles.length > 0 || vbprojFiles.length > 0 || fsprojFiles.length > 0;
+            const hasSolution = slnFiles.length > 0;
+
+            if (hasProjectFiles || hasSolution) {
+                return {
+                    detected: true,
+                    confidence: 'high',
+                    indicators: {
+                        csproj: csprojFiles.length,
+                        vbproj: vbprojFiles.length,
+                        fsproj: fsprojFiles.length,
+                        solution: slnFiles.length
+                    }
+                };
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return { detected: false };
+    }
+
+    /**
+     * Find files by extension
+     */
+    async findFilesByExtension(extension: string): Promise<string[]> {
+        try {
+            const files = await fs.readdir(this.projectPath);
+            return files.filter(file => file.endsWith(extension));
+        } catch (error) {
+            return [];
+        }
+    }
+
+    /**
+     * Determine primary project type
+     */
+    determinePrimaryType(detected: Record<string, ProjectTypeInfo>): string {
+        const priorities = ['angular', 'springBoot', 'react', 'vue', 'nodejs', 'java', 'python', 'dotnet'];
+
+        for (const type of priorities) {
+            if (detected[type] && detected[type].confidence === 'high') {
+                return type;
+            }
+        }
+
+        // Fallback to first detected
+        return Object.keys(detected)[0] || 'unknown';
+    }
+}