@grafema/core 0.1.0-alpha.1

package/dist/core/WorkerPool.js

@@ -0,0 +1,109 @@
+/**
+ * WorkerPool - worker pool for parallel task execution
+ *
+ * Key property: HORIZONTAL SCALING
+ * More workers = faster processing (up to CPU/IO limit)
+ */
+import { EventEmitter } from 'events';
+export class WorkerPool extends EventEmitter {
+    workerCount;
+    handlers;
+    activeWorkers;
+    running;
+    constructor(workerCount = 10, handlers = {}) {
+        super();
+        this.workerCount = workerCount;
+        this.handlers = handlers;
+        this.activeWorkers = 0;
+        this.running = false;
+    }
+    /**
+     * Register handler for task type
+     */
+    registerHandler(taskType, handler) {
+        this.handlers[taskType] = handler;
+    }
+    /**
+     * Start queue processing
+     */
+    async processQueue(queue) {
+        this.running = true;
+        this.emit('pool:started', { workerCount: this.workerCount });
+        // Create workers
+        const workers = [];
+        for (let i = 0; i < this.workerCount; i++) {
+            workers.push(this._worker(i, queue));
+        }
+        // Wait for all workers to complete
+        await Promise.all(workers);
+        this.running = false;
+        this.emit('pool:finished', queue.getStats());
+    }
+    /**
+     * Worker - picks task from queue and executes
+     */
+    async _worker(workerId, queue) {
+        while (true) {
+            // If queue is empty AND no active workers - exit
+            if (queue.isEmpty && this.activeWorkers === 0) {
+                break;
+            }
+            // Get next task
+            const task = queue.next();
+            if (!task) {
+                // No ready tasks, wait a bit
+                await this._sleep(10);
+                continue;
+            }
+            this.activeWorkers++;
+            this.emit('worker:task:start', { workerId, task });
+            this.emit('worker:task:started', task); // For progress tracking
+            try {
+                // Execute task
+                const handler = task.type ? this.handlers[task.type] : undefined;
+                if (!handler) {
+                    throw new Error(`No handler for task type: ${task.type}`);
+                }
+                task.start();
+                const result = await handler(task);
+                queue.complete(task.id, result);
+                this.emit('worker:task:completed', { workerId, task, result });
+            }
+            catch (error) {
+                queue.fail(task.id, error);
+                this.emit('worker:task:failed', { workerId, task, error });
+            }
+            finally {
+                this.activeWorkers--;
+            }
+        }
+        this.emit('worker:stopped', { workerId });
+    }
+    /**
+     * Sleep helper
+     */
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Stop pool (graceful shutdown)
+     */
+    async stop() {
+        this.running = false;
+        // Wait for all active workers to complete current tasks
+        while (this.activeWorkers > 0) {
+            await this._sleep(100);
+        }
+        this.emit('pool:stopped');
+    }
+    /**
+     * Statistics
+     */
+    getStats() {
+        return {
+            workerCount: this.workerCount,
+            activeWorkers: this.activeWorkers,
+            running: this.running
+        };
+    }
+}

package/dist/core/nodes/CallSiteNode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * CallSiteNode - contract for CALL_SITE node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface CallSiteNodeRecord extends BaseNodeRecord {
+    type: 'CALL_SITE';
+    column: number;
+    parentScopeId?: string;
+    targetFunctionName: string;
+}
+interface CallSiteNodeOptions {
+    parentScopeId?: string;
+    counter?: number;
+}
+export declare class CallSiteNode {
+    static readonly TYPE: "CALL_SITE";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["column", "parentScopeId", "targetFunctionName"];
+    /**
+     * Create CALL_SITE node
+     */
+    static create(targetName: string, file: string, line: number, column: number, options?: CallSiteNodeOptions): CallSiteNodeRecord;
+    static validate(node: CallSiteNodeRecord): string[];
+}
+export type { CallSiteNodeRecord };
+//# sourceMappingURL=CallSiteNode.d.ts.map

package/dist/core/nodes/CallSiteNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallSiteNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/CallSiteNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,kBAAmB,SAAQ,cAAc;IACjD,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,UAAU,mBAAmB;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,YAAY;IACvB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,WAAW,CAAU;IAE5C,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,6DAA8D;IAEtF;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB,GAChC,kBAAkB;IAoBrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,EAAE;CAgBpD;AAED,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/core/nodes/CallSiteNode.js

@@ -0,0 +1,44 @@
+/**
+ * CallSiteNode - contract for CALL_SITE node
+ */
+export class CallSiteNode {
+    static TYPE = 'CALL_SITE';
+    static REQUIRED = ['name', 'file', 'line'];
+    static OPTIONAL = ['column', 'parentScopeId', 'targetFunctionName'];
+    /**
+     * Create CALL_SITE node
+     */
+    static create(targetName, file, line, column, options = {}) {
+        if (!targetName)
+            throw new Error('CallSiteNode.create: targetName is required');
+        if (!file)
+            throw new Error('CallSiteNode.create: file is required');
+        if (line === undefined)
+            throw new Error('CallSiteNode.create: line is required');
+        const counter = options.counter !== undefined ? `:${options.counter}` : '';
+        const id = `${file}:CALL_SITE:${targetName}:${line}:${column || 0}${counter}`;
+        return {
+            id,
+            type: this.TYPE,
+            name: targetName,
+            file,
+            line,
+            column: column || 0,
+            parentScopeId: options.parentScopeId,
+            targetFunctionName: targetName
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined || nodeRecord[field] === null) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/ClassNode.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ClassNode - contract for CLASS node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface ClassNodeRecord extends BaseNodeRecord {
+    type: 'CLASS';
+    column: number;
+    exported: boolean;
+    superClass?: string;
+    methods: string[];
+}
+interface ClassNodeOptions {
+    exported?: boolean;
+    superClass?: string;
+    methods?: string[];
+}
+export declare class ClassNode {
+    static readonly TYPE: "CLASS";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["column", "exported", "superClass", "methods"];
+    static create(name: string, file: string, line: number, column: number, options?: ClassNodeOptions): ClassNodeRecord;
+    static validate(node: ClassNodeRecord): string[];
+}
+export type { ClassNodeRecord };
+//# sourceMappingURL=ClassNode.d.ts.map

package/dist/core/nodes/ClassNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ClassNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,eAAgB,SAAQ,cAAc;IAC9C,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,UAAU,gBAAgB;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,qBAAa,SAAS;IACpB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IAExC,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,2DAA4D;IAEpF,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAqB,GAC7B,eAAe;IAkBlB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE;CAgBjD;AAED,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/core/nodes/ClassNode.js

@@ -0,0 +1,40 @@
+/**
+ * ClassNode - contract for CLASS node
+ */
+export class ClassNode {
+    static TYPE = 'CLASS';
+    static REQUIRED = ['name', 'file', 'line'];
+    static OPTIONAL = ['column', 'exported', 'superClass', 'methods'];
+    static create(name, file, line, column, options = {}) {
+        if (!name)
+            throw new Error('ClassNode.create: name is required');
+        if (!file)
+            throw new Error('ClassNode.create: file is required');
+        if (!line)
+            throw new Error('ClassNode.create: line is required');
+        return {
+            id: `${file}:CLASS:${name}:${line}`,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column: column || 0,
+            exported: options.exported || false,
+            superClass: options.superClass,
+            methods: options.methods || []
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (!nodeRecord[field]) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/ConstantNode.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ConstantNode - contract for CONSTANT node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface ConstantNodeRecord extends BaseNodeRecord {
+    type: 'CONSTANT';
+    column: number;
+    value?: unknown;
+    parentScopeId?: string;
+}
+interface ConstantNodeOptions {
+    value?: unknown;
+    parentScopeId?: string;
+    counter?: number;
+}
+export declare class ConstantNode {
+    static readonly TYPE: "CONSTANT";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["column", "value", "parentScopeId"];
+    static create(name: string, file: string, line: number, column: number, options?: ConstantNodeOptions): ConstantNodeRecord;
+    static validate(node: ConstantNodeRecord): string[];
+}
+export type { ConstantNodeRecord };
+//# sourceMappingURL=ConstantNode.d.ts.map

package/dist/core/nodes/ConstantNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstantNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ConstantNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,kBAAmB,SAAQ,cAAc;IACjD,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,mBAAmB;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,YAAY;IACvB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAU;IAE3C,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,gDAAiD;IAEzE,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB,GAChC,kBAAkB;IAoBrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,EAAE;CASpD;AAED,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/core/nodes/ConstantNode.js

@@ -0,0 +1,39 @@
+/**
+ * ConstantNode - contract for CONSTANT node
+ */
+export class ConstantNode {
+    static TYPE = 'CONSTANT';
+    static REQUIRED = ['name', 'file', 'line'];
+    static OPTIONAL = ['column', 'value', 'parentScopeId'];
+    static create(name, file, line, column, options = {}) {
+        if (!name)
+            throw new Error('ConstantNode.create: name is required');
+        if (!file)
+            throw new Error('ConstantNode.create: file is required');
+        if (line === undefined)
+            throw new Error('ConstantNode.create: line is required');
+        const counter = options.counter !== undefined ? `:${options.counter}` : '';
+        const id = `${file}:CONSTANT:${name}:${line}:${column || 0}${counter}`;
+        return {
+            id,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column: column || 0,
+            value: options.value,
+            parentScopeId: options.parentScopeId
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE)
+            errors.push(`Expected type ${this.TYPE}`);
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined)
+                errors.push(`Missing: ${field}`);
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/DatabaseQueryNode.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DatabaseQueryNode - contract for DATABASE_QUERY node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface DatabaseQueryNodeRecord extends BaseNodeRecord {
+    type: 'DATABASE_QUERY';
+    query?: string;
+    operation: string;
+    parentScopeId?: string;
+}
+interface DatabaseQueryNodeOptions {
+    parentScopeId?: string;
+}
+export declare class DatabaseQueryNode {
+    static readonly TYPE: "DATABASE_QUERY";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["query", "operation", "parentScopeId"];
+    static create(query: string | undefined, operation: string | undefined, file: string, line: number, options?: DatabaseQueryNodeOptions): DatabaseQueryNodeRecord;
+    static validate(node: DatabaseQueryNodeRecord): string[];
+}
+export type { DatabaseQueryNodeRecord };
+//# sourceMappingURL=DatabaseQueryNode.d.ts.map

package/dist/core/nodes/DatabaseQueryNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseQueryNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/DatabaseQueryNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,uBAAwB,SAAQ,cAAc;IACtD,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,wBAAwB;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,gBAAgB,CAAU;IAEjD,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,mDAAoD;IAE5E,MAAM,CAAC,MAAM,CACX,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,wBAA6B,GACrC,uBAAuB;IAmB1B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,EAAE;CASzD;AAED,YAAY,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/core/nodes/DatabaseQueryNode.js

@@ -0,0 +1,37 @@
+/**
+ * DatabaseQueryNode - contract for DATABASE_QUERY node
+ */
+export class DatabaseQueryNode {
+    static TYPE = 'DATABASE_QUERY';
+    static REQUIRED = ['name', 'file', 'line'];
+    static OPTIONAL = ['query', 'operation', 'parentScopeId'];
+    static create(query, operation, file, line, options = {}) {
+        if (!file)
+            throw new Error('DatabaseQueryNode.create: file is required');
+        if (line === undefined)
+            throw new Error('DatabaseQueryNode.create: line is required');
+        const name = query || `${operation || 'QUERY'}`;
+        const id = `${file}:DATABASE_QUERY:${name}:${line}`;
+        return {
+            id,
+            type: this.TYPE,
+            name,
+            query,
+            operation: operation || 'UNKNOWN',
+            file,
+            line,
+            parentScopeId: options.parentScopeId
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE)
+            errors.push(`Expected type ${this.TYPE}`);
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined)
+                errors.push(`Missing: ${field}`);
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/EntrypointNode.d.ts

@@ -0,0 +1,102 @@
+/**
+ * EntrypointNode - represents an executable entry point
+ *
+ * An ENTRYPOINT is any file that can be executed directly:
+ * - service: main app entrypoint (package.json main/bin)
+ * - cli: command-line tool
+ * - test: test file
+ * - script: dev/build script (package.json scripts)
+ * - hook: git/tool hook (.husky/*, hooks/*.mjs)
+ * - config: build config (*.config.js)
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+export declare const ENTRYPOINT_TYPES: {
+    readonly SERVICE: "service";
+    readonly CLI: "cli";
+    readonly TEST: "test";
+    readonly SCRIPT: "script";
+    readonly HOOK: "hook";
+    readonly CONFIG: "config";
+};
+export type EntrypointType = typeof ENTRYPOINT_TYPES[keyof typeof ENTRYPOINT_TYPES];
+export declare const ENTRYPOINT_TRIGGERS: {
+    readonly RUNTIME: "runtime";
+    readonly BUILD: "build";
+    readonly DEV: "dev";
+    readonly CI: "ci";
+    readonly MANUAL: "manual";
+};
+export type EntrypointTrigger = typeof ENTRYPOINT_TRIGGERS[keyof typeof ENTRYPOINT_TRIGGERS];
+export declare const ENTRYPOINT_SOURCES: {
+    readonly PACKAGE_MAIN: "package.json:main";
+    readonly PACKAGE_BIN: "package.json:bin";
+    readonly PACKAGE_SCRIPT: "package.json:scripts";
+    readonly CONVENTION: "convention";
+    readonly CONFIG: "config";
+    readonly MANUAL: "manual";
+};
+export type EntrypointSource = typeof ENTRYPOINT_SOURCES[keyof typeof ENTRYPOINT_SOURCES];
+interface EntrypointNodeRecord extends BaseNodeRecord {
+    type: 'ENTRYPOINT';
+    entrypointType: EntrypointType;
+    trigger: EntrypointTrigger;
+    source: string;
+    serviceId: string | null;
+}
+interface EntrypointNodeOptions {
+    id?: string;
+    name?: string;
+    trigger?: EntrypointTrigger;
+    source?: string;
+    serviceId?: string;
+}
+export declare class EntrypointNode {
+    static readonly TYPE: "ENTRYPOINT";
+    static readonly REQUIRED: readonly ["file", "entrypointType"];
+    static readonly OPTIONAL: readonly ["trigger", "source", "serviceId", "name"];
+    static readonly TYPES: {
+        readonly SERVICE: "service";
+        readonly CLI: "cli";
+        readonly TEST: "test";
+        readonly SCRIPT: "script";
+        readonly HOOK: "hook";
+        readonly CONFIG: "config";
+    };
+    static readonly TRIGGERS: {
+        readonly RUNTIME: "runtime";
+        readonly BUILD: "build";
+        readonly DEV: "dev";
+        readonly CI: "ci";
+        readonly MANUAL: "manual";
+    };
+    static readonly SOURCES: {
+        readonly PACKAGE_MAIN: "package.json:main";
+        readonly PACKAGE_BIN: "package.json:bin";
+        readonly PACKAGE_SCRIPT: "package.json:scripts";
+        readonly CONVENTION: "convention";
+        readonly CONFIG: "config";
+        readonly MANUAL: "manual";
+    };
+    /**
+     * Create ENTRYPOINT node
+     */
+    static create(file: string, entrypointType: EntrypointType, options?: EntrypointNodeOptions): EntrypointNodeRecord;
+    /**
+     * Generate stable ID for entrypoint
+     */
+    static generateId(file: string, type: string): string;
+    /**
+     * Extract name from file path
+     */
+    static extractName(file: string): string;
+    /**
+     * Infer trigger from entrypoint type
+     */
+    static inferTrigger(entrypointType: EntrypointType): EntrypointTrigger;
+    /**
+     * Validate ENTRYPOINT node
+     */
+    static validate(node: EntrypointNodeRecord): string[];
+}
+export type { EntrypointNodeRecord };
+//# sourceMappingURL=EntrypointNode.d.ts.map

package/dist/core/nodes/EntrypointNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntrypointNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/EntrypointNode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,eAAO,MAAM,gBAAgB;;;;;;;CAOnB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAGpF,eAAO,MAAM,mBAAmB;;;;;;CAMtB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAG7F,eAAO,MAAM,kBAAkB;;;;;;;CAOrB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,OAAO,kBAAkB,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE1F,UAAU,oBAAqB,SAAQ,cAAc;IACnD,IAAI,EAAE,YAAY,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,UAAU,qBAAqB;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAc;IACzB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IAE7C,MAAM,CAAC,QAAQ,CAAC,QAAQ,sCAAuC;IAC/D,MAAM,CAAC,QAAQ,CAAC,QAAQ,sDAAuD;IAE/E,MAAM,CAAC,QAAQ,CAAC,KAAK;;;;;;;MAAoB;IACzC,MAAM,CAAC,QAAQ,CAAC,QAAQ;;;;;;MAAuB;IAC/C,MAAM,CAAC,QAAQ,CAAC,OAAO;;;;;;;MAAsB;IAE7C;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,cAAc,EAC9B,OAAO,GAAE,qBAA0B,GAClC,oBAAoB;IAmBvB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAKrD;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAKxC;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,cAAc,EAAE,cAAc,GAAG,iBAAiB;IAiBtE;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,EAAE;CAoBtD;AAED,YAAY,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/core/nodes/EntrypointNode.js

@@ -0,0 +1,119 @@
+/**
+ * EntrypointNode - represents an executable entry point
+ *
+ * An ENTRYPOINT is any file that can be executed directly:
+ * - service: main app entrypoint (package.json main/bin)
+ * - cli: command-line tool
+ * - test: test file
+ * - script: dev/build script (package.json scripts)
+ * - hook: git/tool hook (.husky/*, hooks/*.mjs)
+ * - config: build config (*.config.js)
+ */
+import { createHash } from 'crypto';
+// Entrypoint types
+export const ENTRYPOINT_TYPES = {
+    SERVICE: 'service', // Main app entrypoint
+    CLI: 'cli', // Command-line tool
+    TEST: 'test', // Test file
+    SCRIPT: 'script', // Dev/build script
+    HOOK: 'hook', // Git/tool hook
+    CONFIG: 'config' // Build config file
+};
+// What triggers execution
+export const ENTRYPOINT_TRIGGERS = {
+    RUNTIME: 'runtime', // Production runtime
+    BUILD: 'build', // Build process
+    DEV: 'dev', // Development
+    CI: 'ci', // CI/CD pipeline
+    MANUAL: 'manual' // Manual execution
+};
+// How entrypoint was discovered
+export const ENTRYPOINT_SOURCES = {
+    PACKAGE_MAIN: 'package.json:main',
+    PACKAGE_BIN: 'package.json:bin',
+    PACKAGE_SCRIPT: 'package.json:scripts',
+    CONVENTION: 'convention',
+    CONFIG: 'config',
+    MANUAL: 'manual'
+};
+export class EntrypointNode {
+    static TYPE = 'ENTRYPOINT';
+    static REQUIRED = ['file', 'entrypointType'];
+    static OPTIONAL = ['trigger', 'source', 'serviceId', 'name'];
+    static TYPES = ENTRYPOINT_TYPES;
+    static TRIGGERS = ENTRYPOINT_TRIGGERS;
+    static SOURCES = ENTRYPOINT_SOURCES;
+    /**
+     * Create ENTRYPOINT node
+     */
+    static create(file, entrypointType, options = {}) {
+        if (!file)
+            throw new Error('EntrypointNode.create: file is required');
+        if (!entrypointType)
+            throw new Error('EntrypointNode.create: entrypointType is required');
+        const id = options.id || this.generateId(file, entrypointType);
+        return {
+            id,
+            type: this.TYPE,
+            file,
+            line: 0,
+            name: options.name || this.extractName(file),
+            entrypointType,
+            trigger: options.trigger || this.inferTrigger(entrypointType),
+            source: options.source || 'unknown',
+            serviceId: options.serviceId || null
+        };
+    }
+    /**
+     * Generate stable ID for entrypoint
+     */
+    static generateId(file, type) {
+        const hash = createHash('md5').update(file).digest('hex').substring(0, 8);
+        return `ENTRYPOINT:${type}:${hash}`;
+    }
+    /**
+     * Extract name from file path
+     */
+    static extractName(file) {
+        const parts = file.split('/');
+        return parts[parts.length - 1];
+    }
+    /**
+     * Infer trigger from entrypoint type
+     */
+    static inferTrigger(entrypointType) {
+        switch (entrypointType) {
+            case this.TYPES.SERVICE:
+            case this.TYPES.CLI:
+                return this.TRIGGERS.RUNTIME;
+            case this.TYPES.TEST:
+                return this.TRIGGERS.CI;
+            case this.TYPES.CONFIG:
+                return this.TRIGGERS.BUILD;
+            case this.TYPES.SCRIPT:
+            case this.TYPES.HOOK:
+                return this.TRIGGERS.DEV;
+            default:
+                return this.TRIGGERS.MANUAL;
+        }
+    }
+    /**
+     * Validate ENTRYPOINT node
+     */
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (!nodeRecord[field]) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        if (node.entrypointType && !Object.values(this.TYPES).includes(node.entrypointType)) {
+            errors.push(`Invalid entrypointType: ${node.entrypointType}`);
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/EventListenerNode.d.ts

@@ -0,0 +1,25 @@
+/**
+ * EventListenerNode - contract for EVENT_LISTENER node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface EventListenerNodeRecord extends BaseNodeRecord {
+    type: 'EVENT_LISTENER';
+    object?: string;
+    parentScopeId?: string;
+    callbackArg?: string;
+}
+interface EventListenerNodeOptions {
+    column?: number;
+    parentScopeId?: string;
+    callbackArg?: string;
+    counter?: number;
+}
+export declare class EventListenerNode {
+    static readonly TYPE: "EVENT_LISTENER";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["object", "column", "parentScopeId", "callbackArg"];
+    static create(eventName: string, objectName: string | undefined, file: string, line: number, options?: EventListenerNodeOptions): EventListenerNodeRecord;
+    static validate(node: EventListenerNodeRecord): string[];
+}
+export type { EventListenerNodeRecord };
+//# sourceMappingURL=EventListenerNode.d.ts.map

package/dist/core/nodes/EventListenerNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventListenerNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/EventListenerNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,uBAAwB,SAAQ,cAAc;IACtD,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,wBAAwB;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,gBAAgB,CAAU;IAEjD,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,gEAAiE;IAEzF,MAAM,CAAC,MAAM,CACX,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,wBAA6B,GACrC,uBAAuB;IAoB1B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,EAAE;CASzD;AAED,YAAY,EAAE,uBAAuB,EAAE,CAAC"}