@pikku/inspector 0.9.5 → 0.10.0

package/dist/utils/serialize-inspector-state.d.ts

@@ -0,0 +1,179 @@
+import { InspectorState } from '../types.js';
+/**
+ * Serializable version of InspectorState that can be saved to JSON
+ * Omits typesLookup (contains non-serializable ts.Type objects) and converts Maps/Sets to arrays
+ */
+export interface SerializableInspectorState {
+    rootDir: string;
+    singletonServicesTypeImportMap: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    sessionServicesTypeImportMap: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    userSessionTypeImportMap: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    configTypeImportMap: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    singletonServicesFactories: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    sessionServicesFactories: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    sessionServicesMeta: Array<[string, string[]]>;
+    configFactories: Array<[
+        string,
+        {
+            variable: string;
+            type: string | null;
+            typePath: string | null;
+        }[]
+    ]>;
+    filesAndMethods: InspectorState['filesAndMethods'];
+    filesAndMethodsErrors: Array<[
+        string,
+        Array<[
+            string,
+            {
+                variable: string;
+                type: string | null;
+                typePath: string | null;
+            }[]
+        ]>
+    ]>;
+    functions: {
+        typesMap: {
+            map: Array<[string, {
+                originalName: string;
+                path: string | null;
+            }]>;
+            customTypes: Array<[string, {
+                type: string;
+                references: string[];
+            }]>;
+        };
+        meta: InspectorState['functions']['meta'];
+        files: Array<[string, {
+            path: string;
+            exportedName: string;
+        }]>;
+    };
+    http: {
+        metaInputTypes: Array<[
+            string,
+            {
+                query: string[] | undefined;
+                params: string[] | undefined;
+                body: string[] | undefined;
+            }
+        ]>;
+        meta: InspectorState['http']['meta'];
+        files: string[];
+        routeMiddleware: Array<[
+            string,
+            InspectorState['http']['routeMiddleware'] extends Map<string, infer V> ? V : never
+        ]>;
+        routePermissions: Array<[
+            string,
+            InspectorState['http']['routePermissions'] extends Map<string, infer V> ? V : never
+        ]>;
+    };
+    channels: {
+        files: string[];
+        meta: InspectorState['channels']['meta'];
+    };
+    scheduledTasks: {
+        meta: InspectorState['scheduledTasks']['meta'];
+        files: string[];
+    };
+    queueWorkers: {
+        meta: InspectorState['queueWorkers']['meta'];
+        files: string[];
+    };
+    rpc: {
+        internalMeta: InspectorState['rpc']['internalMeta'];
+        internalFiles: Array<[string, {
+            path: string;
+            exportedName: string;
+        }]>;
+        exposedMeta: InspectorState['rpc']['exposedMeta'];
+        exposedFiles: Array<[string, {
+            path: string;
+            exportedName: string;
+        }]>;
+        invokedFunctions: string[];
+    };
+    mcpEndpoints: {
+        resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta'];
+        toolsMeta: InspectorState['mcpEndpoints']['toolsMeta'];
+        promptsMeta: InspectorState['mcpEndpoints']['promptsMeta'];
+        files: string[];
+    };
+    cli: {
+        meta: InspectorState['cli']['meta'];
+        files: string[];
+    };
+    middleware: {
+        meta: InspectorState['middleware']['meta'];
+        tagMiddleware: Array<[
+            string,
+            InspectorState['middleware']['tagMiddleware'] extends Map<string, infer V> ? V : never
+        ]>;
+    };
+    permissions: {
+        meta: InspectorState['permissions']['meta'];
+        tagPermissions: Array<[
+            string,
+            InspectorState['permissions']['tagPermissions'] extends Map<string, infer V> ? V : never
+        ]>;
+    };
+    serviceAggregation: {
+        requiredServices: string[];
+        usedFunctions: string[];
+        usedMiddleware: string[];
+        usedPermissions: string[];
+    };
+}
+/**
+ * Serializes InspectorState to a JSON-compatible format
+ * Omits typesLookup (not needed for filtering/generation) and converts Maps/Sets to arrays
+ */
+export declare function serializeInspectorState(state: InspectorState): SerializableInspectorState;
+/**
+ * Deserializes JSON data back to InspectorState
+ * Creates a partial state suitable for filtering/generation (without typesLookup)
+ */
+export declare function deserializeInspectorState(data: SerializableInspectorState): Omit<InspectorState, 'typesLookup'>;

package/dist/utils/serialize-inspector-state.js

@@ -0,0 +1,170 @@
+import { TypesMap } from '../types-map.js';
+/**
+ * Serializes InspectorState to a JSON-compatible format
+ * Omits typesLookup (not needed for filtering/generation) and converts Maps/Sets to arrays
+ */
+export function serializeInspectorState(state) {
+    // Helper to serialize TypesMap
+    const serializeTypesMap = (typesMap) => {
+        // Access private map via type assertion
+        const mapEntries = Array.from(typesMap.map.entries());
+        const customTypesEntries = Array.from(typesMap.customTypes.entries());
+        return {
+            map: mapEntries,
+            customTypes: customTypesEntries,
+        };
+    };
+    return {
+        rootDir: state.rootDir,
+        singletonServicesTypeImportMap: Array.from(state.singletonServicesTypeImportMap.entries()),
+        sessionServicesTypeImportMap: Array.from(state.sessionServicesTypeImportMap.entries()),
+        userSessionTypeImportMap: Array.from(state.userSessionTypeImportMap.entries()),
+        configTypeImportMap: Array.from(state.configTypeImportMap.entries()),
+        singletonServicesFactories: Array.from(state.singletonServicesFactories.entries()),
+        sessionServicesFactories: Array.from(state.sessionServicesFactories.entries()),
+        sessionServicesMeta: Array.from(state.sessionServicesMeta.entries()),
+        configFactories: Array.from(state.configFactories.entries()),
+        filesAndMethods: state.filesAndMethods,
+        filesAndMethodsErrors: Array.from(state.filesAndMethodsErrors.entries()).map(([key, mapValue]) => [key, Array.from(mapValue.entries())]),
+        functions: {
+            typesMap: serializeTypesMap(state.functions.typesMap),
+            meta: state.functions.meta,
+            files: Array.from(state.functions.files.entries()),
+        },
+        http: {
+            metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
+            meta: state.http.meta,
+            files: Array.from(state.http.files),
+            routeMiddleware: Array.from(state.http.routeMiddleware.entries()),
+            routePermissions: Array.from(state.http.routePermissions.entries()),
+        },
+        channels: {
+            files: Array.from(state.channels.files),
+            meta: state.channels.meta,
+        },
+        scheduledTasks: {
+            meta: state.scheduledTasks.meta,
+            files: Array.from(state.scheduledTasks.files),
+        },
+        queueWorkers: {
+            meta: state.queueWorkers.meta,
+            files: Array.from(state.queueWorkers.files),
+        },
+        rpc: {
+            internalMeta: state.rpc.internalMeta,
+            internalFiles: Array.from(state.rpc.internalFiles.entries()),
+            exposedMeta: state.rpc.exposedMeta,
+            exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
+            invokedFunctions: Array.from(state.rpc.invokedFunctions),
+        },
+        mcpEndpoints: {
+            resourcesMeta: state.mcpEndpoints.resourcesMeta,
+            toolsMeta: state.mcpEndpoints.toolsMeta,
+            promptsMeta: state.mcpEndpoints.promptsMeta,
+            files: Array.from(state.mcpEndpoints.files),
+        },
+        cli: {
+            meta: state.cli.meta,
+            files: Array.from(state.cli.files),
+        },
+        middleware: {
+            meta: state.middleware.meta,
+            tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
+        },
+        permissions: {
+            meta: state.permissions.meta,
+            tagPermissions: Array.from(state.permissions.tagPermissions.entries()),
+        },
+        serviceAggregation: {
+            requiredServices: Array.from(state.serviceAggregation.requiredServices),
+            usedFunctions: Array.from(state.serviceAggregation.usedFunctions),
+            usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
+            usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
+        },
+    };
+}
+/**
+ * Deserializes JSON data back to InspectorState
+ * Creates a partial state suitable for filtering/generation (without typesLookup)
+ */
+export function deserializeInspectorState(data) {
+    // Helper to deserialize TypesMap
+    const deserializeTypesMap = (serialized) => {
+        const typesMap = new TypesMap();
+        typesMap.map = new Map(serialized.map);
+        // Restore public customTypes
+        typesMap.customTypes = new Map(serialized.customTypes);
+        return typesMap;
+    };
+    return {
+        rootDir: data.rootDir,
+        singletonServicesTypeImportMap: new Map(data.singletonServicesTypeImportMap),
+        sessionServicesTypeImportMap: new Map(data.sessionServicesTypeImportMap),
+        userSessionTypeImportMap: new Map(data.userSessionTypeImportMap),
+        configTypeImportMap: new Map(data.configTypeImportMap),
+        singletonServicesFactories: new Map(data.singletonServicesFactories),
+        sessionServicesFactories: new Map(data.sessionServicesFactories),
+        sessionServicesMeta: new Map(data.sessionServicesMeta),
+        configFactories: new Map(data.configFactories),
+        filesAndMethods: data.filesAndMethods,
+        filesAndMethodsErrors: new Map(data.filesAndMethodsErrors.map(([key, entries]) => [
+            key,
+            new Map(entries),
+        ])),
+        functions: {
+            typesMap: deserializeTypesMap(data.functions.typesMap),
+            meta: data.functions.meta,
+            files: new Map(data.functions.files),
+        },
+        http: {
+            metaInputTypes: new Map(data.http.metaInputTypes),
+            meta: data.http.meta,
+            files: new Set(data.http.files),
+            routeMiddleware: new Map(data.http.routeMiddleware),
+            routePermissions: new Map(data.http.routePermissions),
+        },
+        channels: {
+            files: new Set(data.channels.files),
+            meta: data.channels.meta,
+        },
+        scheduledTasks: {
+            meta: data.scheduledTasks.meta,
+            files: new Set(data.scheduledTasks.files),
+        },
+        queueWorkers: {
+            meta: data.queueWorkers.meta,
+            files: new Set(data.queueWorkers.files),
+        },
+        rpc: {
+            internalMeta: data.rpc.internalMeta,
+            internalFiles: new Map(data.rpc.internalFiles),
+            exposedMeta: data.rpc.exposedMeta,
+            exposedFiles: new Map(data.rpc.exposedFiles),
+            invokedFunctions: new Set(data.rpc.invokedFunctions),
+        },
+        mcpEndpoints: {
+            resourcesMeta: data.mcpEndpoints.resourcesMeta,
+            toolsMeta: data.mcpEndpoints.toolsMeta,
+            promptsMeta: data.mcpEndpoints.promptsMeta,
+            files: new Set(data.mcpEndpoints.files),
+        },
+        cli: {
+            meta: data.cli.meta,
+            files: new Set(data.cli.files),
+        },
+        middleware: {
+            meta: data.middleware.meta,
+            tagMiddleware: new Map(data.middleware.tagMiddleware),
+        },
+        permissions: {
+            meta: data.permissions.meta,
+            tagPermissions: new Map(data.permissions.tagPermissions),
+        },
+        serviceAggregation: {
+            requiredServices: new Set(data.serviceAggregation.requiredServices),
+            usedFunctions: new Set(data.serviceAggregation.usedFunctions),
+            usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
+            usedPermissions: new Set(data.serviceAggregation.usedPermissions),
+        },
+    };
+}

package/dist/utils/type-utils.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+export declare const extractTypeKeys: (type: ts.Type) => string[];
+export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;

package/dist/utils/type-utils.js

@@ -0,0 +1,50 @@
+import * as ts from 'typescript';
+export const extractTypeKeys = (type) => {
+    return type.getProperties().map((symbol) => symbol.getName());
+};
+export function getPropertyAssignmentInitializer(obj, propName, followShorthand = false, checker) {
+    for (const prop of obj.properties) {
+        // ①  foo: () => {}
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop.initializer;
+        }
+        // ②  foo() { … }
+        if (ts.isMethodDeclaration(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop.name; // the method node *is* the function
+        }
+        // ③  { foo }  (shorthand)
+        if (followShorthand &&
+            ts.isShorthandPropertyAssignment(prop) &&
+            prop.name.text === propName) {
+            if (!checker)
+                return prop.name; // best effort without a checker
+            let sym = checker.getSymbolAtLocation(prop.name);
+            if (sym && sym.flags & ts.SymbolFlags.Alias) {
+                sym = checker.getAliasedSymbol(sym);
+            }
+            const decl = sym?.declarations?.[0];
+            // const foo = () => {}
+            if (decl &&
+                ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                (ts.isArrowFunction(decl.initializer) ||
+                    ts.isFunctionExpression(decl.initializer))) {
+                return decl.initializer;
+            }
+            // function foo() {}
+            if (decl &&
+                (ts.isFunctionDeclaration(decl) ||
+                    ts.isArrowFunction(decl) ||
+                    ts.isFunctionExpression(decl))) {
+                return decl;
+            }
+            // fallback – just give back the identifier
+            return prop.name;
+        }
+    }
+    return undefined;
+}

package/dist/visit.d.ts

@@ -1,4 +1,4 @@
 import * as ts from 'typescript';
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js';
-export declare const visitSetup: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;
-export declare const visitRoutes: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;
+import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+export declare const visitSetup: (logger: InspectorLogger, checker: ts.TypeChecker, node: ts.Node, state: InspectorState, options: InspectorOptions) => void;
+export declare const visitRoutes: (logger: InspectorLogger, checker: ts.TypeChecker, node: ts.Node, state: InspectorState, options: InspectorOptions) => void;

package/dist/visit.js

@@ -1,37 +1,41 @@
 import * as ts from 'typescript';
-import { addFileWithFactory } from './add-file-with-factory.js';
-import { addFileExtendsCoreType } from './add-file-extends-core-type.js';
-import { addHTTPRoute } from './add-http-route.js';
-import { addSchedule } from './add-schedule.js';
-import { addQueueWorker } from './add-queue-worker.js';
-import { addMCPResource } from './add-mcp-resource.js';
-import { addMCPTool } from './add-mcp-tool.js';
-import { addMCPPrompt } from './add-mcp-prompt.js';
-import { addFunctions } from './add-functions.js';
-import { addChannel } from './add-channel.js';
-import { addRPCInvocations } from './add-rpc-invocations.js';
-import { addMiddleware } from './add-middleware.js';
-import { addPermission } from './add-permission.js';
-export const visitSetup = (checker, node, state, filters, logger) => {
-    addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices');
-    addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices');
-    addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession');
+import { addFileWithFactory } from './add/add-file-with-factory.js';
+import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
+import { addHTTPRoute } from './add/add-http-route.js';
+import { addSchedule } from './add/add-schedule.js';
+import { addQueueWorker } from './add/add-queue-worker.js';
+import { addMCPResource } from './add/add-mcp-resource.js';
+import { addMCPTool } from './add/add-mcp-tool.js';
+import { addMCPPrompt } from './add/add-mcp-prompt.js';
+import { addFunctions } from './add/add-functions.js';
+import { addChannel } from './add/add-channel.js';
+import { addRPCInvocations } from './add/add-rpc-invocations.js';
+import { addMiddleware } from './add/add-middleware.js';
+import { addPermission } from './add/add-permission.js';
+import { addCLI, addCLIRenderers } from './add/add-cli.js';
+export const visitSetup = (logger, checker, node, state, options) => {
+    addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
+    addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices', state);
+    addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession', state);
+    addFileExtendsCoreType(node, checker, state.configTypeImportMap, 'CoreConfig', state);
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
-    addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
+    addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addRPCInvocations(node, state, logger);
-    ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters, logger));
+    addMiddleware(logger, node, checker, state, options);
+    addPermission(logger, node, checker, state, options);
+    ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));
 };
-export const visitRoutes = (checker, node, state, filters, logger) => {
-    addFunctions(node, checker, state, logger);
-    addHTTPRoute(node, checker, state, filters, logger);
-    addSchedule(node, checker, state, filters, logger);
-    addQueueWorker(node, checker, state, filters, logger);
-    addChannel(node, checker, state, filters, logger);
-    addMCPResource(node, checker, state, filters, logger);
-    addMCPTool(node, checker, state, filters, logger);
-    addMCPPrompt(node, checker, state, filters, logger);
-    addMiddleware(node, checker, state, logger);
-    addPermission(node, checker, state, logger);
-    ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters, logger));
+export const visitRoutes = (logger, checker, node, state, options) => {
+    addFunctions(logger, node, checker, state, options);
+    addHTTPRoute(logger, node, checker, state, options);
+    addSchedule(logger, node, checker, state, options);
+    addQueueWorker(logger, node, checker, state, options);
+    addChannel(logger, node, checker, state, options);
+    addCLI(logger, node, checker, state, options);
+    addCLIRenderers(logger, node, checker, state, options);
+    addMCPResource(logger, node, checker, state, options);
+    addMCPTool(logger, node, checker, state, options);
+    addMCPPrompt(logger, node, checker, state, options);
+    ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, options));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.9.5",
+  "version": "0.10.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -8,8 +8,7 @@
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc",
-    "build:esm": "tsc -b",
-    "build": "yarn build:esm",
+    "build": "tsc -b",
     "ncu": "npx npm-check-updates -x '/.*glob.*/'",
     "release": "yarn build && npm test",
     "test": "bash run-tests.sh",
@@ -17,12 +16,12 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.9.6",
-    "path-to-regexp": "^8.2.0",
+    "@pikku/core": "^0.10.0",
+    "path-to-regexp": "^8.3.0",
     "typescript": "^5.9"
   },
   "devDependencies": {
-    "@types/node": "^24.2.1"
+    "@types/node": "^24.9.1"
   },
   "engines": {
     "node": ">=18"