projax 1.3.0 → 1.3.1

package/dist/electron/core/detector.js

@@ -0,0 +1,284 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRAMEWORKS = void 0;
+exports.detectTestFramework = detectTestFramework;
+exports.isTestFile = isTestFile;
+exports.detectProjectFramework = detectProjectFramework;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.FRAMEWORKS = [
+    {
+        name: 'jest',
+        configFiles: ['jest.config.js', 'jest.config.ts', 'jest.config.json', 'jest.config.mjs', 'jest.config.cjs'],
+        testPatterns: [
+            /\.test\.(js|ts|jsx|tsx)$/i,
+            /\.spec\.(js|ts|jsx|tsx)$/i,
+        ],
+        testDirs: ['__tests__', '__test__'],
+    },
+    {
+        name: 'vitest',
+        configFiles: ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs'],
+        testPatterns: [
+            /\.test\.(js|ts|jsx|tsx)$/i,
+            /\.spec\.(js|ts|jsx|tsx)$/i,
+        ],
+        testDirs: ['__tests__'],
+    },
+    {
+        name: 'mocha',
+        configFiles: ['.mocharc.js', '.mocharc.json', '.mocharc.yaml', '.mocharc.yml', 'mocha.opts'],
+        testPatterns: [
+            /\.test\.(js|ts|jsx|tsx)$/i,
+            /\.spec\.(js|ts|jsx|tsx)$/i,
+        ],
+        testDirs: ['test', 'tests'],
+    },
+];
+function detectTestFramework(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    // Check package.json for test scripts and dependencies
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            // Check dependencies and devDependencies
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            if (deps.jest)
+                return 'jest';
+            if (deps.vitest)
+                return 'vitest';
+            if (deps.mocha)
+                return 'mocha';
+            // Check for jest config in package.json
+            if (packageJson.jest)
+                return 'jest';
+            // Check test scripts
+            if (packageJson.scripts) {
+                const testScript = packageJson.scripts.test || '';
+                if (testScript.includes('jest'))
+                    return 'jest';
+                if (testScript.includes('vitest'))
+                    return 'vitest';
+                if (testScript.includes('mocha'))
+                    return 'mocha';
+            }
+        }
+        catch (error) {
+            // Invalid JSON, continue with file-based detection
+        }
+    }
+    // Check for config files
+    for (const framework of exports.FRAMEWORKS) {
+        for (const configFile of framework.configFiles) {
+            const configPath = path.join(projectPath, configFile);
+            if (fs.existsSync(configPath)) {
+                return framework.name;
+            }
+        }
+    }
+    return null;
+}
+function isTestFile(filePath, detectedFramework = null) {
+    const fileName = path.basename(filePath);
+    const dirName = path.dirname(filePath);
+    const parentDirName = path.basename(dirName);
+    // If framework is detected, use its specific patterns
+    if (detectedFramework) {
+        const framework = exports.FRAMEWORKS.find(f => f.name === detectedFramework);
+        if (framework) {
+            // Check test patterns
+            for (const pattern of framework.testPatterns) {
+                if (pattern.test(fileName)) {
+                    return true;
+                }
+            }
+            // Check test directories
+            for (const testDir of framework.testDirs) {
+                if (parentDirName === testDir) {
+                    return true;
+                }
+            }
+        }
+    }
+    // Fallback: check all common patterns
+    for (const framework of exports.FRAMEWORKS) {
+        for (const pattern of framework.testPatterns) {
+            if (pattern.test(fileName)) {
+                return true;
+            }
+        }
+        for (const testDir of framework.testDirs) {
+            if (parentDirName === testDir) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Detect the main framework/library used in a project
+ * Returns null if no framework is detected
+ */
+function detectProjectFramework(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        // Check for non-JS projects
+        if (fs.existsSync(path.join(projectPath, 'Cargo.toml')))
+            return 'rust';
+        if (fs.existsSync(path.join(projectPath, 'go.mod')))
+            return 'go';
+        if (fs.existsSync(path.join(projectPath, 'requirements.txt')) ||
+            fs.existsSync(path.join(projectPath, 'setup.py')) ||
+            fs.existsSync(path.join(projectPath, 'pyproject.toml'))) {
+            return 'python';
+        }
+        return null;
+    }
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        // Meta-frameworks (check these first as they often include the base frameworks)
+        if (deps['next'] || deps['next.js'])
+            return 'next.js';
+        if (deps['@nuxt/kit'] || deps['nuxt'] || deps['nuxt3'])
+            return 'nuxt.js';
+        if (deps['gatsby'])
+            return 'gatsby';
+        if (deps['@remix-run/react'] || deps['remix'])
+            return 'remix';
+        if (deps['@astro'] || deps['astro'])
+            return 'astro';
+        if (deps['@angular/core'])
+            return 'angular';
+        if (deps['expo'] || deps['expo-cli'])
+            return 'expo';
+        // React Native (check before React)
+        if (deps['react-native'])
+            return 'react-native';
+        // Frontend frameworks
+        if (deps['react'] || deps['react-dom'])
+            return 'react';
+        if (deps['vue']) {
+            // Check Vue version
+            const vueVersion = deps['vue']?.match(/\d+/)?.[0];
+            return vueVersion === '3' ? 'vue 3' : 'vue';
+        }
+        if (deps['svelte'])
+            return 'svelte';
+        if (deps['solid-js'])
+            return 'solid';
+        if (deps['preact'])
+            return 'preact';
+        if (deps['alpine'] || deps['alpinejs'])
+            return 'alpine.js';
+        if (deps['lit'] || deps['lit-element'])
+            return 'lit';
+        if (deps['hyperapp'])
+            return 'hyperapp';
+        if (deps['mithril'])
+            return 'mithril';
+        if (deps['inferno'])
+            return 'inferno';
+        if (deps['marko'])
+            return 'marko';
+        // Backend frameworks
+        if (deps['express'])
+            return 'express';
+        if (deps['@nestjs/core'])
+            return 'nest.js';
+        if (deps['fastify'])
+            return 'fastify';
+        if (deps['koa'])
+            return 'koa';
+        if (deps['hapi'] || deps['@hapi/hapi'])
+            return 'hapi';
+        if (deps['@apollo/server'] || deps['apollo-server'])
+            return 'apollo';
+        if (deps['graphql'] && (deps['@graphql-yoga/node'] || deps['graphql-yoga']))
+            return 'graphql-yoga';
+        if (deps['@trpc/server'])
+            return 'trpc';
+        if (deps['@redwoodjs/core'])
+            return 'redwood.js';
+        if (deps['@blitzjs/core'])
+            return 'blitz.js';
+        // Electron
+        if (deps['electron'])
+            return 'electron';
+        // Static site generators
+        if (deps['@11ty/eleventy'])
+            return '11ty';
+        if (deps['hexo'])
+            return 'hexo';
+        if (deps['jekyll'])
+            return 'jekyll';
+        if (deps['hugo'])
+            return 'hugo';
+        // Mobile development
+        if (deps['@ionic/core'] || deps['@ionic/angular'] || deps['@ionic/react'])
+            return 'ionic';
+        if (deps['@nativescript/core'])
+            return 'nativescript';
+        if (deps['@capacitor/core'])
+            return 'capacitor';
+        if (deps['cordova'])
+            return 'cordova';
+        // Desktop development
+        if (deps['tauri'])
+            return 'tauri';
+        if (deps['nw.js'] || deps['nw'])
+            return 'nw.js';
+        // Build tools / bundlers (as last resort)
+        if (deps['vite'])
+            return 'vite';
+        if (deps['webpack'])
+            return 'webpack';
+        if (deps['parcel'])
+            return 'parcel';
+        if (deps['rollup'])
+            return 'rollup';
+        if (deps['esbuild'])
+            return 'esbuild';
+        if (deps['turbopack'])
+            return 'turbopack';
+        // Generic Node.js if no specific framework found but package.json exists
+        return 'node.js';
+    }
+    catch (error) {
+        // Invalid JSON or read error
+        return null;
+    }
+}

package/dist/electron/core/index.d.ts

@@ -0,0 +1,10 @@
+export * from './database';
+export * from './detector';
+export * from './scanner';
+export * from './settings';
+export { getDatabaseManager } from './database';
+import { Project, Test } from './database';
+export declare function getAllProjects(): Project[];
+export declare function addProject(name: string, projectPath: string): Project;
+export declare function removeProject(id: number): void;
+export declare function getTestsByProject(projectId: number): Test[];

package/dist/electron/core/index.js

@@ -0,0 +1,41 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDatabaseManager = void 0;
+exports.getAllProjects = getAllProjects;
+exports.addProject = addProject;
+exports.removeProject = removeProject;
+exports.getTestsByProject = getTestsByProject;
+__exportStar(require("./database"), exports);
+__exportStar(require("./detector"), exports);
+__exportStar(require("./scanner"), exports);
+__exportStar(require("./settings"), exports);
+var database_1 = require("./database");
+Object.defineProperty(exports, "getDatabaseManager", { enumerable: true, get: function () { return database_1.getDatabaseManager; } });
+// Convenience functions for common operations
+const database_2 = require("./database");
+function getAllProjects() {
+    return (0, database_2.getDatabaseManager)().getAllProjects();
+}
+function addProject(name, projectPath) {
+    return (0, database_2.getDatabaseManager)().addProject(name, projectPath);
+}
+function removeProject(id) {
+    (0, database_2.getDatabaseManager)().removeProject(id);
+}
+function getTestsByProject(projectId) {
+    return (0, database_2.getDatabaseManager)().getTestsByProject(projectId);
+}

package/dist/electron/core/scanner.d.ts

@@ -0,0 +1,8 @@
+import { Project, Test } from './database';
+export interface ScanResult {
+    project: Project;
+    testsFound: number;
+    tests: Test[];
+}
+export declare function scanProject(projectId: number): ScanResult;
+export declare function scanAllProjects(): ScanResult[];

package/dist/electron/core/scanner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProject = scanProject;
+exports.scanAllProjects = scanAllProjects;
+const database_1 = require("./database");
+function scanProject(projectId) {
+    return (0, database_1.getDatabaseManager)().scanProject(projectId);
+}
+function scanAllProjects() {
+    return (0, database_1.getDatabaseManager)().scanAllProjects();
+}

package/dist/electron/core/settings.d.ts

@@ -0,0 +1,50 @@
+export type EditorType = 'vscode' | 'cursor' | 'windsurf' | 'zed' | 'custom';
+export type BrowserType = 'chrome' | 'firefox' | 'safari' | 'edge' | 'custom';
+export interface EditorSettings {
+    type: EditorType;
+    customPath?: string;
+}
+export interface BrowserSettings {
+    type: BrowserType;
+    customPath?: string;
+}
+export interface AppSettings {
+    editor: EditorSettings;
+    browser: BrowserSettings;
+}
+/**
+ * Get a setting value by key
+ */
+export declare function getSetting(key: string): string | null;
+/**
+ * Set a setting value by key
+ */
+export declare function setSetting(key: string, value: string): void;
+/**
+ * Get all settings as a key-value object
+ */
+export declare function getAllSettings(): Record<string, string>;
+/**
+ * Get editor settings
+ */
+export declare function getEditorSettings(): EditorSettings;
+/**
+ * Set editor settings
+ */
+export declare function setEditorSettings(settings: EditorSettings): void;
+/**
+ * Get browser settings
+ */
+export declare function getBrowserSettings(): BrowserSettings;
+/**
+ * Set browser settings
+ */
+export declare function setBrowserSettings(settings: BrowserSettings): void;
+/**
+ * Get all app settings
+ */
+export declare function getAppSettings(): AppSettings;
+/**
+ * Set all app settings
+ */
+export declare function setAppSettings(settings: AppSettings): void;

package/dist/electron/core/settings.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSetting = getSetting;
+exports.setSetting = setSetting;
+exports.getAllSettings = getAllSettings;
+exports.getEditorSettings = getEditorSettings;
+exports.setEditorSettings = setEditorSettings;
+exports.getBrowserSettings = getBrowserSettings;
+exports.setBrowserSettings = setBrowserSettings;
+exports.getAppSettings = getAppSettings;
+exports.setAppSettings = setAppSettings;
+const database_1 = require("./database");
+const DEFAULT_SETTINGS = {
+    editor: {
+        type: 'vscode',
+    },
+    browser: {
+        type: 'chrome',
+    },
+};
+/**
+ * Get a setting value by key
+ */
+function getSetting(key) {
+    return (0, database_1.getDatabaseManager)().getSetting(key);
+}
+/**
+ * Set a setting value by key
+ */
+function setSetting(key, value) {
+    (0, database_1.getDatabaseManager)().setSetting(key, value);
+}
+/**
+ * Get all settings as a key-value object
+ */
+function getAllSettings() {
+    return (0, database_1.getDatabaseManager)().getAllSettings();
+}
+/**
+ * Get editor settings
+ */
+function getEditorSettings() {
+    const db = (0, database_1.getDatabaseManager)();
+    const type = db.getSetting('editor.type') || DEFAULT_SETTINGS.editor.type;
+    const customPath = db.getSetting('editor.customPath') || undefined;
+    return {
+        type,
+        customPath,
+    };
+}
+/**
+ * Set editor settings
+ */
+function setEditorSettings(settings) {
+    const db = (0, database_1.getDatabaseManager)();
+    db.setSetting('editor.type', settings.type);
+    if (settings.customPath) {
+        db.setSetting('editor.customPath', settings.customPath);
+    }
+    // Note: Removing settings is not yet supported via the API
+    // Setting to empty string would achieve similar effect if needed
+}
+/**
+ * Get browser settings
+ */
+function getBrowserSettings() {
+    const db = (0, database_1.getDatabaseManager)();
+    const type = db.getSetting('browser.type') || DEFAULT_SETTINGS.browser.type;
+    const customPath = db.getSetting('browser.customPath') || undefined;
+    return {
+        type,
+        customPath,
+    };
+}
+/**
+ * Set browser settings
+ */
+function setBrowserSettings(settings) {
+    const db = (0, database_1.getDatabaseManager)();
+    db.setSetting('browser.type', settings.type);
+    if (settings.customPath) {
+        db.setSetting('browser.customPath', settings.customPath);
+    }
+    // Note: Removing settings is not yet supported via the API
+    // Setting to empty string would achieve similar effect if needed
+}
+/**
+ * Get all app settings
+ */
+function getAppSettings() {
+    return {
+        editor: getEditorSettings(),
+        browser: getBrowserSettings(),
+    };
+}
+/**
+ * Set all app settings
+ */
+function setAppSettings(settings) {
+    setEditorSettings(settings.editor);
+    setBrowserSettings(settings.browser);
+}

package/dist/electron/core.d.ts

@@ -0,0 +1,2 @@
+export declare const getDatabaseManager: typeof import("projax-core").getDatabaseManager, addProject: typeof import("projax-core").addProject, removeProject: typeof import("projax-core").removeProject, getAllProjects: typeof import("projax-core").getAllProjects, scanProject: typeof import("projax-core").scanProject, scanAllProjects: typeof import("projax-core").scanAllProjects, getTestsByProject: typeof import("projax-core").getTestsByProject;
+export type { Project, Test, ProjectPort, JenkinsJob } from 'projax-core';

package/dist/electron/core.js

@@ -0,0 +1,76 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestsByProject = exports.scanAllProjects = exports.scanProject = exports.getAllProjects = exports.removeProject = exports.addProject = exports.getDatabaseManager = void 0;
+const path = __importStar(require("path"));
+let cachedCore = null;
+function tryRequire(candidate) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require(candidate);
+    }
+    catch (error) {
+        if (!(error instanceof Error) ||
+            !('code' in error) ||
+            error.code !== 'MODULE_NOT_FOUND') {
+            throw error;
+        }
+        return null;
+    }
+}
+function resolveCore() {
+    if (cachedCore) {
+        return cachedCore;
+    }
+    const candidates = [
+        // Packaged desktop build (core copied into dist/core)
+        path.join(__dirname, 'core'),
+        // Running from workspace build output
+        path.join(__dirname, '..', '..', 'core', 'dist'),
+        path.join(__dirname, '..', 'core', 'dist'),
+        // Fallback: installed module (during development)
+        'projax-core',
+    ];
+    for (const candidate of candidates) {
+        const mod = tryRequire(candidate);
+        if (mod) {
+            cachedCore = mod;
+            return mod;
+        }
+    }
+    throw new Error(`Unable to load projax core module. Tried locations: ${candidates.join(', ')}`);
+}
+const core = resolveCore();
+exports.getDatabaseManager = core.getDatabaseManager, exports.addProject = core.addProject, exports.removeProject = core.removeProject, exports.getAllProjects = core.getAllProjects, exports.scanProject = core.scanProject, exports.scanAllProjects = core.scanAllProjects, exports.getTestsByProject = core.getTestsByProject;