projax 1.0.1 → 1.3.0

package/dist/core/database.js

@@ -32,274 +32,202 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDatabaseManager = getDatabaseManager;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
 class DatabaseManager {
-    db = null;
-    dbPath;
+    apiBaseUrl;
+    defaultPort = 3001;
     constructor() {
+        // Read API port from file, or use default
         const dataDir = path.join(os.homedir(), '.projax');
-        const oldDataDir = path.join(os.homedir(), '.vids-dashboard');
-        const oldDbPath = path.join(oldDataDir, 'dashboard.db');
-        // Migrate data from old directory if it exists
-        const newDbPath = path.join(dataDir, 'dashboard.db');
-        if (fs.existsSync(oldDataDir) && fs.existsSync(oldDbPath) && !fs.existsSync(newDbPath)) {
-            console.log('Migrating data from ~/.vids-dashboard to ~/.projax...');
+        const portFile = path.join(dataDir, 'api-port.txt');
+        let port = this.defaultPort;
+        if (fs.existsSync(portFile)) {
             try {
-                // Create new directory
-                fs.mkdirSync(dataDir, { recursive: true });
-                // Copy database file
-                fs.copyFileSync(oldDbPath, newDbPath);
-                console.log('✓ Database migrated successfully');
-                // Copy other files (processes.json, logs directory)
-                const oldProcessesFile = path.join(oldDataDir, 'processes.json');
-                if (fs.existsSync(oldProcessesFile)) {
-                    const newProcessesFile = path.join(dataDir, 'processes.json');
-                    fs.copyFileSync(oldProcessesFile, newProcessesFile);
+                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);
                 }
-                const oldLogsDir = path.join(oldDataDir, 'logs');
-                if (fs.existsSync(oldLogsDir)) {
-                    const newLogsDir = path.join(dataDir, 'logs');
-                    fs.mkdirSync(newLogsDir, { recursive: true });
-                    // Copy all log files
-                    const logFiles = fs.readdirSync(oldLogsDir);
-                    for (const file of logFiles) {
-                        const oldLogPath = path.join(oldLogsDir, file);
-                        const newLogPath = path.join(newLogsDir, file);
-                        if (fs.statSync(oldLogPath).isFile()) {
-                            fs.copyFileSync(oldLogPath, newLogPath);
-                        }
-                    }
+                catch {
+                    // Ignore cleanup errors
                 }
-                console.log('✓ Migration complete. You can safely remove ~/.vids-dashboard if desired.');
             }
-            catch (error) {
-                console.error('⚠️  Migration failed:', error);
-                console.error('   Continuing with new directory. Old data remains in ~/.vids-dashboard');
+            if (!result || result.trim() === '') {
+                return undefined;
             }
+            return JSON.parse(result);
         }
-        else if (!fs.existsSync(dataDir)) {
-            fs.mkdirSync(dataDir, { recursive: true });
-        }
-        this.dbPath = path.join(dataDir, 'dashboard.db');
-    }
-    getDatabase() {
-        if (!this.db) {
-            this.db = new better_sqlite3_1.default(this.dbPath);
-            this.db.pragma('journal_mode = WAL');
-            this.initializeSchema();
+        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'}`);
         }
-        return this.db;
-    }
-    initializeSchema() {
-        if (!this.db)
-            return;
-        // Projects table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS projects (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        path TEXT NOT NULL UNIQUE,
-        last_scanned INTEGER,
-        created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
-      )
-    `);
-        // Tests table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS tests (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        project_id INTEGER NOT NULL,
-        file_path TEXT NOT NULL,
-        framework TEXT,
-        status TEXT,
-        last_run INTEGER,
-        created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
-        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-        UNIQUE(project_id, file_path)
-      )
-    `);
-        // Jenkins jobs table (for future integration)
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS jenkins_jobs (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        project_id INTEGER NOT NULL,
-        job_name TEXT NOT NULL,
-        job_url TEXT NOT NULL,
-        last_build_status TEXT,
-        last_build_number INTEGER,
-        last_updated INTEGER,
-        created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
-        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-        UNIQUE(project_id, job_name)
-      )
-    `);
-        // Project ports table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS project_ports (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        project_id INTEGER NOT NULL,
-        port INTEGER NOT NULL,
-        script_name TEXT,
-        config_source TEXT NOT NULL,
-        last_detected INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
-        created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
-        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-        UNIQUE(project_id, port, script_name)
-      )
-    `);
-        // Create indexes
-        this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_tests_project_id ON tests(project_id);
-      CREATE INDEX IF NOT EXISTS idx_jenkins_jobs_project_id ON jenkins_jobs(project_id);
-      CREATE INDEX IF NOT EXISTS idx_project_ports_project_id ON project_ports(project_id);
-      CREATE INDEX IF NOT EXISTS idx_project_ports_port ON project_ports(port);
-    `);
     }
     // Project operations
     addProject(name, projectPath) {
-        const db = this.getDatabase();
-        const stmt = db.prepare(`
-      INSERT INTO projects (name, path)
-      VALUES (?, ?)
-    `);
-        const result = stmt.run(name, projectPath);
-        return this.getProject(result.lastInsertRowid);
+        return this.request('/projects', {
+            method: 'POST',
+            body: JSON.stringify({ name, path: projectPath }),
+        });
     }
     getProject(id) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM projects WHERE id = ?');
-        return stmt.get(id);
+        try {
+            return this.request(`/projects/${id}`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('404')) {
+                return null;
+            }
+            throw error;
+        }
     }
     getProjectByPath(projectPath) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM projects WHERE path = ?');
-        return stmt.get(projectPath);
+        const projects = this.getAllProjects();
+        return projects.find(p => p.path === projectPath) || null;
     }
     getAllProjects() {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM projects ORDER BY id');
-        return stmt.all();
+        return this.request('/projects');
     }
     updateProjectLastScanned(id) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('UPDATE projects SET last_scanned = strftime("%s", "now") WHERE id = ?');
-        stmt.run(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) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('UPDATE projects SET name = ? WHERE id = ?');
-        stmt.run(newName, id);
-        const updated = this.getProject(id);
-        if (!updated) {
-            throw new Error('Failed to update project name');
-        }
-        return updated;
+        return this.request(`/projects/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify({ name: newName }),
+        });
     }
     removeProject(id) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('DELETE FROM projects WHERE id = ?');
-        stmt.run(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) {
-        const db = this.getDatabase();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO tests (project_id, file_path, framework)
-      VALUES (?, ?, ?)
-    `);
-        const result = stmt.run(projectId, filePath, framework);
-        return this.getTest(result.lastInsertRowid);
+        // Tests are added via scan endpoint, not directly
+        throw new Error('addTest should not be called directly. Use scan endpoint instead.');
     }
     getTest(id) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM tests WHERE id = ?');
-        return stmt.get(id);
+        // This endpoint doesn't exist yet
+        throw new Error('getTest endpoint not yet implemented in API');
     }
     getTestsByProject(projectId) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM tests WHERE project_id = ? ORDER BY file_path');
-        return stmt.all(projectId);
+        return this.request(`/projects/${projectId}/tests`);
     }
     removeTestsByProject(projectId) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('DELETE FROM tests WHERE project_id = ?');
-        stmt.run(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 (for future use)
+    // Jenkins operations
     addJenkinsJob(projectId, jobName, jobUrl) {
-        const db = this.getDatabase();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO jenkins_jobs (project_id, job_name, job_url)
-      VALUES (?, ?, ?)
-    `);
-        const result = stmt.run(projectId, jobName, jobUrl);
-        return this.getJenkinsJob(result.lastInsertRowid);
+        // This endpoint doesn't exist yet
+        throw new Error('addJenkinsJob endpoint not yet implemented in API');
     }
     getJenkinsJob(id) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM jenkins_jobs WHERE id = ?');
-        return stmt.get(id);
+        // This endpoint doesn't exist yet
+        throw new Error('getJenkinsJob endpoint not yet implemented in API');
     }
     getJenkinsJobsByProject(projectId) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM jenkins_jobs WHERE project_id = ? ORDER BY job_name');
-        return stmt.all(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) {
-        const db = this.getDatabase();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO project_ports (project_id, port, script_name, config_source, last_detected)
-      VALUES (?, ?, ?, ?, strftime('%s', 'now'))
-    `);
-        const result = stmt.run(projectId, port, scriptName, configSource);
-        const portRecord = this.getProjectPort(result.lastInsertRowid);
-        if (!portRecord) {
-            throw new Error('Failed to create project port record');
-        }
-        return portRecord;
+        // This endpoint doesn't exist yet
+        throw new Error('addProjectPort endpoint not yet implemented in API');
     }
     getProjectPort(id) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM project_ports WHERE id = ?');
-        return stmt.get(id);
+        // This endpoint doesn't exist yet
+        throw new Error('getProjectPort endpoint not yet implemented in API');
     }
     getProjectPorts(projectId) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM project_ports WHERE project_id = ? ORDER BY port');
-        return stmt.all(projectId);
+        return this.request(`/projects/${projectId}/ports`);
     }
     getProjectPortsByScript(projectId, scriptName) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('SELECT * FROM project_ports WHERE project_id = ? AND script_name = ? ORDER BY port');
-        return stmt.all(projectId, scriptName);
+        const ports = this.getProjectPorts(projectId);
+        return ports.filter(p => p.script_name === scriptName);
     }
     removeProjectPorts(projectId) {
-        const db = this.getDatabase();
-        const stmt = db.prepare('DELETE FROM project_ports WHERE project_id = ?');
-        stmt.run(projectId);
+        // This endpoint doesn't exist yet
+        throw new Error('removeProjectPorts endpoint not yet implemented in API');
     }
     updateProjectPortLastDetected(projectId, port, scriptName) {
-        const db = this.getDatabase();
-        const stmt = db.prepare(`
-      UPDATE project_ports 
-      SET last_detected = strftime('%s', 'now')
-      WHERE project_id = ? AND port = ? AND (script_name = ? OR (script_name IS NULL AND ? IS NULL))
-    `);
-        stmt.run(projectId, port, scriptName, 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() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
+        // No-op for API client
     }
 }
 // Singleton instance

package/dist/core/detector.d.ts

@@ -7,3 +7,8 @@ export interface TestFramework {
 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/core/detector.js

@@ -36,6 +36,7 @@ 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 = [
@@ -147,3 +148,137 @@ function isTestFile(filePath, detectedFramework = null) {
     }
     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/core/index.d.ts

@@ -1,11 +1,10 @@
 export * from './database';
 export * from './detector';
 export * from './scanner';
+export * from './settings';
 export { getDatabaseManager } from './database';
 import { Project, Test } from './database';
-import { scanProject, scanAllProjects } from './scanner';
 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[];
-export { scanProject, scanAllProjects };

package/dist/core/index.js

@@ -14,7 +14,7 @@ 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.scanAllProjects = exports.scanProject = exports.getDatabaseManager = void 0;
+exports.getDatabaseManager = void 0;
 exports.getAllProjects = getAllProjects;
 exports.addProject = addProject;
 exports.removeProject = removeProject;
@@ -22,13 +22,11 @@ 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");
-const scanner_1 = require("./scanner");
-Object.defineProperty(exports, "scanProject", { enumerable: true, get: function () { return scanner_1.scanProject; } });
-Object.defineProperty(exports, "scanAllProjects", { enumerable: true, get: function () { return scanner_1.scanAllProjects; } });
 function getAllProjects() {
     return (0, database_2.getDatabaseManager)().getAllProjects();
 }