projax 0.1.29

package/LINKING.md

@@ -0,0 +1,86 @@
+# Linking the CLI Locally
+
+The CLI can be linked locally using `npm link`. This allows you to use the `prx` command globally while developing.
+
+## Option 1: Standard npm link (if you have permissions)
+
+```bash
+cd packages/cli
+npm link
+```
+
+This will create a global symlink. You can then use `prx` from anywhere:
+
+```bash
+prx --help
+prx add /path/to/project
+```
+
+## Option 2: If you get permission errors
+
+If you get `EACCES` permission errors, you have a few options:
+
+### A. Use a user-writable npm prefix (Recommended)
+
+Configure npm to use a directory in your home folder:
+
+```bash
+mkdir -p ~/.npm-global
+npm config set prefix '~/.npm-global'
+```
+
+Add to your `~/.zshrc` or `~/.bashrc`:
+```bash
+export PATH=~/.npm-global/bin:$PATH
+```
+
+Then reload your shell and link:
+```bash
+source ~/.zshrc  # or source ~/.bashrc
+cd packages/cli
+npm link
+```
+
+### B. Use sudo (Not recommended, but works)
+
+```bash
+cd packages/cli
+sudo npm link
+```
+
+### C. Use npx to run directly
+
+You can also run the CLI directly without linking:
+
+```bash
+# From the project root
+npx --package=./packages/cli prx --help
+
+# Or use node directly
+node packages/cli/dist/index.js --help
+```
+
+## Unlinking
+
+To remove the global link:
+
+```bash
+npm unlink -g prx-dashboard
+```
+
+Or from the CLI package directory:
+
+```bash
+cd packages/cli
+npm unlink
+```
+
+## Testing the Link
+
+After linking, test it:
+
+```bash
+prx --help
+prx list
+```
+

package/README.md

@@ -0,0 +1,141 @@
+# projax CLI
+
+Command-line interface for projax - a project management dashboard for tracking local development projects.
+
+## Installation
+
+```bash
+npm install -g projax
+```
+
+## Commands
+
+### `prx add [path]`
+
+Add a project to the dashboard. If no path is provided, you'll be prompted to enter one.
+
+```bash
+prx add /path/to/project
+prx add  # Interactive mode
+```
+
+### `prx list`
+
+List all tracked projects.
+
+```bash
+prx list
+prx list --verbose  # Show detailed information
+```
+
+### `prx scan [project]`
+
+Scan projects for test files. If no project is specified, all projects are scanned.
+
+```bash
+prx scan              # Scan all projects
+prx scan 1            # Scan project with ID 1
+prx scan my-project   # Scan project named "my-project"
+```
+
+### `prx remove <project>`
+
+Remove a project from the dashboard.
+
+```bash
+prx remove 1
+prx remove my-project
+prx remove my-project --force  # Skip confirmation
+```
+
+### `prx cd [project]`
+
+Get the path to a project directory for quick navigation. Use with command substitution to change directories.
+
+```bash
+cd $(prx cd 1)              # Change to project with ID 1
+cd $(prx cd my-project)     # Change to project named "my-project"
+prx cd                      # Interactive selection
+```
+
+**Tip:** For even easier navigation, add this to your shell config (`~/.zshrc` or `~/.bashrc`):
+
+```bash
+prxcd() {
+  cd $(prx cd "$@")
+}
+```
+
+Then you can simply use: `prxcd 1` or `prxcd my-project`
+
+### `prx <project> <script> [args...]`
+
+Run a script from a project's configuration file. Supports multiple project types:
+
+- **Node.js**: Runs scripts from `package.json` using `npm run`
+- **Python**: Runs scripts from `pyproject.toml` (supports Poetry)
+- **Rust**: Runs common `cargo` commands (build, run, test, etc.)
+- **Go**: Runs common `go` commands or Makefile targets
+- **Makefile**: Runs Makefile targets
+
+```bash
+prx 1 dev                    # Run "dev" script from project ID 1
+prx my-project build          # Run "build" script from "my-project"
+prx 2 test --watch           # Run "test" script with --watch flag
+prx api-server start --port 3000  # Run "start" script with arguments
+```
+
+### `prx scripts [project]`
+
+List all available scripts for a project.
+
+```bash
+prx scripts                  # Interactive project selection
+prx scripts 1                # List scripts for project ID 1
+prx scripts my-project       # List scripts for "my-project"
+```
+
+### `prx web`
+
+Start the Electron web interface.
+
+```bash
+prx web
+```
+
+## Examples
+
+```bash
+# Add multiple projects
+prx add ~/projects/api-server
+prx add ~/projects/frontend-app
+prx add ~/projects/mobile-app
+
+# List all projects
+prx list
+
+# Scan all projects for tests
+prx scan
+
+# View detailed project information
+prx list --verbose
+
+# Remove a project
+prx remove api-server
+
+# Quickly navigate to a project
+cd $(prx cd api-server)
+
+# Run scripts from projects
+prx api-server dev
+prx 1 build
+prx frontend-app test --watch
+
+# List available scripts
+prx scripts api-server
+```
+
+## Database
+
+The CLI uses a shared SQLite database located at `~/.projax/dashboard.db`. This database is shared with the Electron web interface.
+

package/dist/core/database.d.ts

@@ -0,0 +1,66 @@
+import Database from 'better-sqlite3';
+export interface Project {
+    id: number;
+    name: string;
+    path: string;
+    last_scanned: number | null;
+    created_at: number;
+}
+export interface Test {
+    id: number;
+    project_id: number;
+    file_path: string;
+    framework: string | null;
+    status: string | null;
+    last_run: number | null;
+    created_at: number;
+}
+export interface JenkinsJob {
+    id: number;
+    project_id: number;
+    job_name: string;
+    job_url: string;
+    last_build_status: string | null;
+    last_build_number: number | null;
+    last_updated: number | null;
+    created_at: number;
+}
+export interface ProjectPort {
+    id: number;
+    project_id: number;
+    port: number;
+    script_name: string | null;
+    config_source: string;
+    last_detected: number;
+    created_at: number;
+}
+declare class DatabaseManager {
+    private db;
+    private dbPath;
+    constructor();
+    getDatabase(): Database.Database;
+    private initializeSchema;
+    addProject(name: string, projectPath: string): Project;
+    getProject(id: number): Project | null;
+    getProjectByPath(projectPath: string): Project | null;
+    getAllProjects(): Project[];
+    updateProjectLastScanned(id: number): void;
+    updateProjectName(id: number, newName: string): Project;
+    removeProject(id: number): void;
+    addTest(projectId: number, filePath: string, framework?: string | null): Test;
+    getTest(id: number): Test | null;
+    getTestsByProject(projectId: number): Test[];
+    removeTestsByProject(projectId: number): void;
+    addJenkinsJob(projectId: number, jobName: string, jobUrl: string): JenkinsJob;
+    getJenkinsJob(id: number): JenkinsJob | null;
+    getJenkinsJobsByProject(projectId: number): JenkinsJob[];
+    addProjectPort(projectId: number, port: number, configSource: string, scriptName?: string | null): ProjectPort;
+    getProjectPort(id: number): ProjectPort | null;
+    getProjectPorts(projectId: number): ProjectPort[];
+    getProjectPortsByScript(projectId: number, scriptName: string): ProjectPort[];
+    removeProjectPorts(projectId: number): void;
+    updateProjectPortLastDetected(projectId: number, port: number, scriptName: string | null): void;
+    close(): void;
+}
+export declare function getDatabaseManager(): DatabaseManager;
+export {};

package/dist/core/database.js

@@ -0,0 +1,312 @@
+"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;
+    };
+})();
+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"));
+class DatabaseManager {
+    db = null;
+    dbPath;
+    constructor() {
+        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...');
+            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 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);
+                        }
+                    }
+                }
+                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');
+            }
+        }
+        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();
+        }
+        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);
+    }
+    getProject(id) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM projects WHERE id = ?');
+        return stmt.get(id);
+    }
+    getProjectByPath(projectPath) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM projects WHERE path = ?');
+        return stmt.get(projectPath);
+    }
+    getAllProjects() {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM projects ORDER BY id');
+        return stmt.all();
+    }
+    updateProjectLastScanned(id) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('UPDATE projects SET last_scanned = strftime("%s", "now") WHERE id = ?');
+        stmt.run(id);
+    }
+    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;
+    }
+    removeProject(id) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('DELETE FROM projects WHERE id = ?');
+        stmt.run(id);
+    }
+    // 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);
+    }
+    getTest(id) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM tests WHERE id = ?');
+        return stmt.get(id);
+    }
+    getTestsByProject(projectId) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM tests WHERE project_id = ? ORDER BY file_path');
+        return stmt.all(projectId);
+    }
+    removeTestsByProject(projectId) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('DELETE FROM tests WHERE project_id = ?');
+        stmt.run(projectId);
+    }
+    // Jenkins operations (for future use)
+    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);
+    }
+    getJenkinsJob(id) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM jenkins_jobs WHERE id = ?');
+        return stmt.get(id);
+    }
+    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);
+    }
+    // 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;
+    }
+    getProjectPort(id) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM project_ports WHERE id = ?');
+        return stmt.get(id);
+    }
+    getProjectPorts(projectId) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('SELECT * FROM project_ports WHERE project_id = ? ORDER BY port');
+        return stmt.all(projectId);
+    }
+    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);
+    }
+    removeProjectPorts(projectId) {
+        const db = this.getDatabase();
+        const stmt = db.prepare('DELETE FROM project_ports WHERE project_id = ?');
+        stmt.run(projectId);
+    }
+    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);
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}
+// Singleton instance
+let dbManager = null;
+function getDatabaseManager() {
+    if (!dbManager) {
+        dbManager = new DatabaseManager();
+    }
+    return dbManager;
+}

package/dist/core/detector.d.ts

@@ -0,0 +1,9 @@
+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;