@grafema/core 0.1.0-alpha.1

package/dist/core/PriorityQueue.d.ts

@@ -0,0 +1,106 @@
+/**
+ * PriorityQueue - fast task queue with priorities
+ *
+ * Uses Map for O(1) access by ID + sorted array for fast retrieval
+ */
+import { EventEmitter } from 'events';
+import type { TaskData, TaskType } from './TaskTypes.js';
+/**
+ * Task status type
+ */
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed';
+/**
+ * Task interface
+ */
+export interface Task {
+    id: string;
+    type: TaskType;
+    priority: number;
+    status: TaskStatus;
+    data: TaskData;
+    retryCount?: number;
+    maxRetries?: number;
+    result?: unknown;
+    error: Error | null;
+    canExecute(completedTasks: Set<string>): boolean;
+    complete(result: unknown): void;
+    fail(error: Error): void;
+    canRetry(): boolean;
+    retry(): void;
+    start(): void;
+}
+/**
+ * Queue statistics
+ */
+export interface QueueStats {
+    total: number;
+    pending: number;
+    running: number;
+    completed: number;
+    failed: number;
+}
+export declare class PriorityQueue extends EventEmitter {
+    private tasks;
+    private sorted;
+    private completedTasks;
+    constructor();
+    /**
+     * Add task to queue
+     */
+    add(task: Task): void;
+    /**
+     * Insert into sorted array (O(log n) search + O(n) insert)
+     * For better performance could use heap, but for <10K tasks array is faster
+     */
+    private _insertSorted;
+    /**
+     * Remove task from sorted array
+     */
+    private _removeSorted;
+    /**
+     * Get next task for execution (highest priority + all dependencies ready)
+     * O(n) in worst case, but O(1) in practice if few dependencies
+     */
+    next(): Task | null;
+    /**
+     * Get task by ID
+     */
+    get(id: string): Task | undefined;
+    /**
+     * Mark task as completed
+     */
+    complete(taskId: string, result: unknown): void;
+    /**
+     * Mark task as failed
+     */
+    fail(taskId: string, error: Error): void;
+    /**
+     * Number of tasks
+     */
+    get size(): number;
+    /**
+     * Number of pending tasks
+     */
+    get pendingCount(): number;
+    /**
+     * Number of completed tasks
+     */
+    get completedCount(): number;
+    /**
+     * All tasks completed?
+     */
+    get isEmpty(): boolean;
+    /**
+     * Statistics
+     */
+    getStats(): QueueStats;
+    /**
+     * Iterate over completed tasks
+     */
+    getCompletedTasks(): Generator<Task>;
+    /**
+     * Clear queue
+     */
+    clear(): void;
+}
+//# sourceMappingURL=PriorityQueue.d.ts.map

package/dist/core/PriorityQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriorityQueue.d.ts","sourceRoot":"","sources":["../../src/core/PriorityQueue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,UAAU,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;IACjD,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACzB,QAAQ,IAAI,OAAO,CAAC;IACpB,KAAK,IAAI,IAAI,CAAC;IACd,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAc;;IASpC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAarB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;;OAGG;IACH,IAAI,IAAI,IAAI,GAAG,IAAI;IASnB;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAIjC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAW/C;;OAEG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAgBxC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,QAAQ,IAAI,UAAU;IAkBtB;;OAEG;IACF,iBAAiB,IAAI,SAAS,CAAC,IAAI,CAAC;IAQrC;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}

package/dist/core/PriorityQueue.js

@@ -0,0 +1,168 @@
+/**
+ * PriorityQueue - fast task queue with priorities
+ *
+ * Uses Map for O(1) access by ID + sorted array for fast retrieval
+ */
+import { EventEmitter } from 'events';
+export class PriorityQueue extends EventEmitter {
+    tasks;
+    sorted;
+    completedTasks;
+    constructor() {
+        super();
+        this.tasks = new Map();
+        this.sorted = [];
+        this.completedTasks = new Set();
+    }
+    /**
+     * Add task to queue
+     */
+    add(task) {
+        if (this.tasks.has(task.id)) {
+            throw new Error(`Task ${task.id} already exists in queue`);
+        }
+        this.tasks.set(task.id, task);
+        // Insert with sort preservation (binary search)
+        this._insertSorted(task);
+        this.emit('task:added', task);
+    }
+    /**
+     * Insert into sorted array (O(log n) search + O(n) insert)
+     * For better performance could use heap, but for <10K tasks array is faster
+     */
+    _insertSorted(task) {
+        let left = 0;
+        let right = this.sorted.length;
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (this.sorted[mid].priority > task.priority) {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
+        }
+        this.sorted.splice(left, 0, task);
+    }
+    /**
+     * Remove task from sorted array
+     */
+    _removeSorted(task) {
+        const index = this.sorted.indexOf(task);
+        if (index !== -1) {
+            this.sorted.splice(index, 1);
+        }
+    }
+    /**
+     * Get next task for execution (highest priority + all dependencies ready)
+     * O(n) in worst case, but O(1) in practice if few dependencies
+     */
+    next() {
+        for (const task of this.sorted) {
+            if (task.status === 'pending' && task.canExecute(this.completedTasks)) {
+                return task;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get task by ID
+     */
+    get(id) {
+        return this.tasks.get(id);
+    }
+    /**
+     * Mark task as completed
+     */
+    complete(taskId, result) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        task.complete(result);
+        this.completedTasks.add(taskId);
+        this._removeSorted(task);
+        this.emit('task:completed', task);
+    }
+    /**
+     * Mark task as failed
+     */
+    fail(taskId, error) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        task.fail(error);
+        // Retry if possible
+        if (task.canRetry()) {
+            task.retry();
+            this.emit('task:retry', task);
+        }
+        else {
+            this._removeSorted(task);
+            this.emit('task:failed', task);
+        }
+    }
+    /**
+     * Number of tasks
+     */
+    get size() {
+        return this.tasks.size;
+    }
+    /**
+     * Number of pending tasks
+     */
+    get pendingCount() {
+        return this.sorted.length;
+    }
+    /**
+     * Number of completed tasks
+     */
+    get completedCount() {
+        return this.completedTasks.size;
+    }
+    /**
+     * All tasks completed?
+     */
+    get isEmpty() {
+        return this.sorted.length === 0;
+    }
+    /**
+     * Statistics
+     */
+    getStats() {
+        const stats = {
+            total: this.size,
+            pending: 0,
+            running: 0,
+            completed: this.completedCount,
+            failed: 0
+        };
+        for (const task of this.tasks.values()) {
+            if (task.status === 'pending')
+                stats.pending++;
+            else if (task.status === 'running')
+                stats.running++;
+            else if (task.status === 'failed')
+                stats.failed++;
+        }
+        return stats;
+    }
+    /**
+     * Iterate over completed tasks
+     */
+    *getCompletedTasks() {
+        for (const task of this.tasks.values()) {
+            if (task.status === 'completed') {
+                yield task;
+            }
+        }
+    }
+    /**
+     * Clear queue
+     */
+    clear() {
+        this.tasks.clear();
+        this.sorted = [];
+        this.completedTasks.clear();
+        this.emit('queue:cleared');
+    }
+}

package/dist/core/Profiler.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Profiler - utility for measuring execution time of code sections
+ *
+ * Usage:
+ *   const profiler = new Profiler('JSASTAnalyzer');
+ *   profiler.start('parse');
+ *   // ... parsing code ...
+ *   profiler.end('parse');
+ *
+ *   profiler.printSummary();
+ */
+/**
+ * Section timing statistics
+ */
+export interface SectionStats {
+    total: number;
+    count: number;
+    min: number;
+    max: number;
+}
+/**
+ * Formatted section stats for display
+ */
+export interface FormattedStats {
+    total: string;
+    count: number;
+    avg: string;
+    min: string;
+    max: string;
+}
+export declare class Profiler {
+    private name;
+    private timings;
+    private activeTimers;
+    private enabled;
+    constructor(name: string);
+    /**
+     * Start timing a section
+     */
+    start(section: string): void;
+    /**
+     * End timing a section and record the duration
+     */
+    end(section: string): void;
+    /**
+     * Measure a sync function execution time
+     */
+    measure<T>(section: string, fn: () => T): T;
+    /**
+     * Measure an async function execution time
+     */
+    measureAsync<T>(section: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get stats for a section
+     */
+    getStats(section: string): SectionStats | undefined;
+    /**
+     * Get all stats
+     */
+    getAllStats(): Record<string, FormattedStats>;
+    /**
+     * Print summary to console
+     */
+    printSummary(): void;
+    /**
+     * Reset all timings
+     */
+    reset(): void;
+    /**
+     * Merge stats from another profiler
+     */
+    merge(other: Profiler): void;
+}
+export declare const globalProfiler: Profiler;
+//# sourceMappingURL=Profiler.d.ts.map

package/dist/core/Profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Profiler.d.ts","sourceRoot":"","sources":["../../src/core/Profiler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,qBAAa,QAAQ;IACnB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,OAAO,CAAU;gBAEb,IAAI,EAAE,MAAM;IAOxB;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK5B;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAuB1B;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAW3C;;OAEG;IACG,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAWxE;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACH,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;IAc7C;;OAEG;IACH,YAAY,IAAI,IAAI;IA0BpB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;CAY7B;AAGD,eAAO,MAAM,cAAc,UAAyB,CAAC"}

package/dist/core/Profiler.js

@@ -0,0 +1,149 @@
+/**
+ * Profiler - utility for measuring execution time of code sections
+ *
+ * Usage:
+ *   const profiler = new Profiler('JSASTAnalyzer');
+ *   profiler.start('parse');
+ *   // ... parsing code ...
+ *   profiler.end('parse');
+ *
+ *   profiler.printSummary();
+ */
+export class Profiler {
+    name;
+    timings;
+    activeTimers;
+    enabled;
+    constructor(name) {
+        this.name = name;
+        this.timings = new Map();
+        this.activeTimers = new Map();
+        this.enabled = process.env.NAVI_PROFILE === '1' || process.env.NAVI_PROFILE === 'true';
+    }
+    /**
+     * Start timing a section
+     */
+    start(section) {
+        if (!this.enabled)
+            return;
+        this.activeTimers.set(section, process.hrtime.bigint());
+    }
+    /**
+     * End timing a section and record the duration
+     */
+    end(section) {
+        if (!this.enabled)
+            return;
+        const startTime = this.activeTimers.get(section);
+        if (!startTime)
+            return;
+        const endTime = process.hrtime.bigint();
+        const durationMs = Number(endTime - startTime) / 1_000_000; // nanoseconds to ms
+        this.activeTimers.delete(section);
+        // Update stats
+        if (!this.timings.has(section)) {
+            this.timings.set(section, { total: 0, count: 0, min: Infinity, max: 0 });
+        }
+        const stats = this.timings.get(section);
+        stats.total += durationMs;
+        stats.count += 1;
+        stats.min = Math.min(stats.min, durationMs);
+        stats.max = Math.max(stats.max, durationMs);
+    }
+    /**
+     * Measure a sync function execution time
+     */
+    measure(section, fn) {
+        if (!this.enabled)
+            return fn();
+        this.start(section);
+        try {
+            return fn();
+        }
+        finally {
+            this.end(section);
+        }
+    }
+    /**
+     * Measure an async function execution time
+     */
+    async measureAsync(section, fn) {
+        if (!this.enabled)
+            return fn();
+        this.start(section);
+        try {
+            return await fn();
+        }
+        finally {
+            this.end(section);
+        }
+    }
+    /**
+     * Get stats for a section
+     */
+    getStats(section) {
+        return this.timings.get(section);
+    }
+    /**
+     * Get all stats
+     */
+    getAllStats() {
+        const result = {};
+        for (const [section, stats] of this.timings) {
+            result[section] = {
+                total: stats.total.toFixed(2),
+                count: stats.count,
+                avg: (stats.total / stats.count).toFixed(2),
+                min: stats.min.toFixed(2),
+                max: stats.max.toFixed(2)
+            };
+        }
+        return result;
+    }
+    /**
+     * Print summary to console
+     */
+    printSummary() {
+        if (!this.enabled || this.timings.size === 0)
+            return;
+        console.log(`\n📊 [${this.name}] Profiling Summary:`);
+        console.log('─'.repeat(80));
+        console.log(`${'Section'.padEnd(30)} ${'Total(ms)'.padStart(12)} ${'Count'.padStart(8)} ${'Avg(ms)'.padStart(10)} ${'Min'.padStart(10)} ${'Max'.padStart(10)}`);
+        console.log('─'.repeat(80));
+        // Sort by total time descending
+        const sorted = [...this.timings.entries()].sort((a, b) => b[1].total - a[1].total);
+        for (const [section, stats] of sorted) {
+            const avg = stats.total / stats.count;
+            console.log(`${section.padEnd(30)} ${stats.total.toFixed(1).padStart(12)} ${String(stats.count).padStart(8)} ${avg.toFixed(2).padStart(10)} ${stats.min.toFixed(2).padStart(10)} ${stats.max.toFixed(2).padStart(10)}`);
+        }
+        console.log('─'.repeat(80));
+        // Total time
+        const totalTime = [...this.timings.values()].reduce((sum, s) => sum + s.total, 0);
+        console.log(`${'TOTAL'.padEnd(30)} ${totalTime.toFixed(1).padStart(12)}`);
+        console.log('');
+    }
+    /**
+     * Reset all timings
+     */
+    reset() {
+        this.timings.clear();
+        this.activeTimers.clear();
+    }
+    /**
+     * Merge stats from another profiler
+     */
+    merge(other) {
+        for (const [section, otherStats] of other.timings) {
+            if (!this.timings.has(section)) {
+                this.timings.set(section, { total: 0, count: 0, min: Infinity, max: 0 });
+            }
+            const stats = this.timings.get(section);
+            stats.total += otherStats.total;
+            stats.count += otherStats.count;
+            stats.min = Math.min(stats.min, otherStats.min);
+            stats.max = Math.max(stats.max, otherStats.max);
+        }
+    }
+}
+// Global profiler instance for aggregating stats
+export const globalProfiler = new Profiler('Global');

package/dist/core/QueueWorker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * QueueWorker - Worker thread for queue-based analysis
+ *
+ * Runs in a worker_thread, receives file tasks, runs applicable plugins,
+ * writes results directly to RFDB.
+ *
+ * Protocol:
+ *   Main -> Worker: { type: 'process', taskId, file, moduleId, moduleName, plugins }
+ *   Worker -> Main: { type: 'done', taskId, stats } | { type: 'error', taskId, error }
+ */
+export {};
+//# sourceMappingURL=QueueWorker.d.ts.map

package/dist/core/QueueWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueueWorker.d.ts","sourceRoot":"","sources":["../../src/core/QueueWorker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}