projax 1.0.2 → 1.3.1

package/dist/electron/core/database.js

@@ -0,0 +1,240 @@
+"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.getDatabaseManager = getDatabaseManager;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+class DatabaseManager {
+    apiBaseUrl;
+    defaultPort = 3001;
+    constructor() {
+        // Read API port from file, or use default
+        const dataDir = path.join(os.homedir(), '.projax');
+        const portFile = path.join(dataDir, 'api-port.txt');
+        let port = this.defaultPort;
+        if (fs.existsSync(portFile)) {
+            try {
+                const portStr = fs.readFileSync(portFile, 'utf-8').trim();
+                port = parseInt(portStr, 10) || this.defaultPort;
+            }
+            catch {
+                // Use default if file read fails
+            }
+        }
+        this.apiBaseUrl = `http://localhost:${port}/api`;
+    }
+    request(endpoint, options = {}) {
+        const url = `${this.apiBaseUrl}${endpoint}`;
+        const method = options.method || 'GET';
+        const body = options.body;
+        try {
+            let curlCmd;
+            if (method === 'GET') {
+                curlCmd = `curl -s -f "${url}"`;
+            }
+            else if (method === 'DELETE') {
+                curlCmd = `curl -s -f -X DELETE "${url}"`;
+            }
+            else {
+                // POST, PUT, PATCH
+                const tempFile = path.join(os.tmpdir(), `prx-${Date.now()}.json`);
+                if (body) {
+                    fs.writeFileSync(tempFile, body);
+                }
+                curlCmd = `curl -s -f -X ${method} -H "Content-Type: application/json" ${body ? `-d @${tempFile}` : ''} "${url}"`;
+            }
+            const result = (0, child_process_1.execSync)(curlCmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+            // Clean up temp file if created
+            if (method !== 'GET' && method !== 'DELETE' && body) {
+                const tempFile = path.join(os.tmpdir(), `prx-${Date.now()}.json`);
+                try {
+                    fs.unlinkSync(tempFile);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            if (!result || result.trim() === '') {
+                return undefined;
+            }
+            return JSON.parse(result);
+        }
+        catch (error) {
+            // Check if it's a 404 or other HTTP error
+            if (error instanceof Error && error.message.includes('404')) {
+                throw new Error('Resource not found');
+            }
+            throw new Error(`API request failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    // Project operations
+    addProject(name, projectPath) {
+        return this.request('/projects', {
+            method: 'POST',
+            body: JSON.stringify({ name, path: projectPath }),
+        });
+    }
+    getProject(id) {
+        try {
+            return this.request(`/projects/${id}`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('404')) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    getProjectByPath(projectPath) {
+        const projects = this.getAllProjects();
+        return projects.find(p => p.path === projectPath) || null;
+    }
+    getAllProjects() {
+        return this.request('/projects');
+    }
+    updateProjectLastScanned(id) {
+        // Fire and forget - this is handled by the scan endpoint
+        // No need to explicitly update last_scanned
+    }
+    updateProjectFramework(id, framework) {
+        // This will be called during scan to update the detected framework
+        this.request(`/projects/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify({ framework }),
+        });
+    }
+    updateProjectName(id, newName) {
+        return this.request(`/projects/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify({ name: newName }),
+        });
+    }
+    removeProject(id) {
+        this.request(`/projects/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    scanProject(id) {
+        return this.request(`/projects/${id}/scan`, {
+            method: 'POST',
+        });
+    }
+    scanAllProjects() {
+        return this.request('/projects/scan/all', {
+            method: 'POST',
+        });
+    }
+    // Test operations
+    addTest(projectId, filePath, framework = null) {
+        // Tests are added via scan endpoint, not directly
+        throw new Error('addTest should not be called directly. Use scan endpoint instead.');
+    }
+    getTest(id) {
+        // This endpoint doesn't exist yet
+        throw new Error('getTest endpoint not yet implemented in API');
+    }
+    getTestsByProject(projectId) {
+        return this.request(`/projects/${projectId}/tests`);
+    }
+    removeTestsByProject(projectId) {
+        // This is handled by the scan endpoint
+        // For now, we'll just call scan which removes and re-adds
+        throw new Error('removeTestsByProject should not be called directly. Use scan endpoint instead.');
+    }
+    // Jenkins operations
+    addJenkinsJob(projectId, jobName, jobUrl) {
+        // This endpoint doesn't exist yet
+        throw new Error('addJenkinsJob endpoint not yet implemented in API');
+    }
+    getJenkinsJob(id) {
+        // This endpoint doesn't exist yet
+        throw new Error('getJenkinsJob endpoint not yet implemented in API');
+    }
+    getJenkinsJobsByProject(projectId) {
+        // This endpoint doesn't exist yet
+        throw new Error('getJenkinsJobsByProject endpoint not yet implemented in API');
+    }
+    // Project port operations
+    addProjectPort(projectId, port, configSource, scriptName = null) {
+        // This endpoint doesn't exist yet
+        throw new Error('addProjectPort endpoint not yet implemented in API');
+    }
+    getProjectPort(id) {
+        // This endpoint doesn't exist yet
+        throw new Error('getProjectPort endpoint not yet implemented in API');
+    }
+    getProjectPorts(projectId) {
+        return this.request(`/projects/${projectId}/ports`);
+    }
+    getProjectPortsByScript(projectId, scriptName) {
+        const ports = this.getProjectPorts(projectId);
+        return ports.filter(p => p.script_name === scriptName);
+    }
+    removeProjectPorts(projectId) {
+        // This endpoint doesn't exist yet
+        throw new Error('removeProjectPorts endpoint not yet implemented in API');
+    }
+    updateProjectPortLastDetected(projectId, port, scriptName) {
+        // This endpoint doesn't exist yet - no-op for now
+        // Ports are updated via the scan endpoint
+    }
+    // Settings operations
+    getSetting(key) {
+        const settings = this.getAllSettings();
+        return settings[key] || null;
+    }
+    setSetting(key, value) {
+        this.request(`/settings/${encodeURIComponent(key)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ value }),
+        });
+    }
+    getAllSettings() {
+        return this.request('/settings');
+    }
+    close() {
+        // No-op for API client
+    }
+}
+// Singleton instance
+let dbManager = null;
+function getDatabaseManager() {
+    if (!dbManager) {
+        dbManager = new DatabaseManager();
+    }
+    return dbManager;
+}

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

@@ -0,0 +1,14 @@
+export interface TestFramework {
+    name: string;
+    configFiles: string[];
+    testPatterns: RegExp[];
+    testDirs: string[];
+}
+export declare const FRAMEWORKS: TestFramework[];
+export declare function detectTestFramework(projectPath: string): string | null;
+export declare function isTestFile(filePath: string, detectedFramework?: string | null): boolean;
+/**
+ * Detect the main framework/library used in a project
+ * Returns null if no framework is detected
+ */
+export declare function detectProjectFramework(projectPath: string): string | null;

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;