@pikku/cli 0.7.0 → 0.7.2

package/bin/pikku-websocket.ts

@@ -0,0 +1,58 @@
+import { Command } from 'commander'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  writeFileInDir,
+} from '../src/utils.js'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { serializeWebsocketWrapper } from '../src/serialize-websocket-wrapper.js'
+
+export const pikkuWebSocket = async ({
+  websocketFile,
+  channelsMapDeclarationFile,
+  packageMappings,
+}: PikkuCLIConfig) => {
+  await logCommandInfoAndTime(
+    'Generating websocket wrapper',
+    'Generated websocket wrapper',
+    [
+      websocketFile === undefined,
+      "websocketFile isn't set in the pikku config",
+    ],
+    async () => {
+      if (!websocketFile) {
+        throw new Error("fetchFile is isn't set in the pikku config")
+      }
+
+      const channelsMapDeclarationPath = getFileImportRelativePath(
+        websocketFile,
+        channelsMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
+      await writeFileInDir(websocketFile, content.join('\n'))
+    }
+  )
+}
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
+    options.tags,
+    true
+  )
+  await pikkuWebSocket(cliConfig)
+}
+
+export const websocket = (program: Command): void => {
+  program
+    .command('websocket')
+    .description('generate websocket wrapper')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import { schemas } from './pikku-schemas.js'
+import { routes } from './pikku-http-routes.js'
+import { nextjs } from './pikku-nextjs.js'
+import { all } from './pikku-all.js'
+import { functionTypes } from './pikku-function-types.js'
+import { routesMap } from './pikku-http-map.js'
+import { fetch } from './pikku-fetch.js'
+import { channels } from './pikku-channels.js'
+import { schedules } from './pikku-scheduler.js'
+
+const program = new Command('pikku')
+program.usage('[command]')
+
+all(program)
+routes(program)
+routesMap(program)
+functionTypes(program)
+schemas(program)
+nextjs(program)
+fetch(program)
+channels(program)
+schedules(program)
+
+program.parse(process.argv)

package/dist/bin/pikku-all.js

@@ -15,6 +15,7 @@ import { pikkuWebSocket } from './pikku-websocket.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
 import { pikkuFunctions } from './pikku-functions.js';
+import { pikkuRPC } from './pikku-rpc.js';
 const runAll = async (cliConfig, options) => {
     const metaImports = [];
     const imports = [];
@@ -45,6 +46,8 @@ const runAll = async (cliConfig, options) => {
     }
     addImport(cliConfig.functionsMetaFile, 'meta');
     addImport(cliConfig.functionsFile, 'events');
+    await pikkuRPC(cliConfig, visitState);
+    addImport(cliConfig.rpcFile, 'meta');
     const routes = await pikkuHTTP(cliConfig, visitState);
     if (routes) {
         await pikkuHTTPMap(cliConfig, visitState);

package/dist/bin/pikku-functions.d.ts

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuFunctions: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
-export declare const routes: (program: Command) => void;

package/dist/bin/pikku-functions.js

@@ -1,24 +1,9 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../src/utils.js';
 export const pikkuFunctions = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding Pikku functions', 'Found Pikku functions', [visitState.functions.files.size === 0], async () => {
         const { functionsFile, functionsMetaFile, packageMappings } = cliConfig;
         const { functions } = visitState;
         await writeFileInDir(functionsFile, serializeFileImports('addFunction', functionsFile, functions.files, packageMappings));
-        await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('functions', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+        await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'functionsFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuFunctions(cliConfig, visitState);
-}
-export const routes = (program) => {
-    program
-        .command('functions')
-        .description('Find all functions to import')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-http-map.js

@@ -4,7 +4,7 @@ import { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuHTTPMap = async ({ httpRoutesMapDeclarationFile, packageMappings }, { http, functions }) => {
     return await logCommandInfoAndTime('Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
-        const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes);
+        const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
         await writeFileInDir(httpRoutesMapDeclarationFile, content);
     });
 };

package/dist/bin/pikku-openapi.js

@@ -9,8 +9,8 @@ export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http, functions }) =
         if (!openAPI?.outputFile) {
             throw new Error('openAPI is required');
         }
-        const schemas = await generateSchemas(tsconfig, [http.typesMap, functions.typesMap], http.meta);
-        const openAPISpec = await generateOpenAPISpec(http.meta, schemas, openAPI.additionalInfo);
+        const schemas = await generateSchemas(tsconfig, functions.typesMap, functions.meta, http.meta);
+        const openAPISpec = await generateOpenAPISpec(functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), true);
         }

package/dist/bin/pikku-rpc.d.ts

@@ -0,0 +1,3 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuRPC: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;

package/dist/bin/pikku-rpc.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils.js';
+export const pikkuRPC = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding RPCs tasks', 'Found rpcs', [visitState.functions.files.size === 0], async () => {
+        const { rpcFile } = cliConfig;
+        const { rpc } = visitState;
+        await writeFileInDir(rpcFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+    });
+};

package/dist/bin/pikku-schemas.js

@@ -4,8 +4,8 @@ import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuSchemas = async ({ tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http, channels }) => {
     return await logCommandInfoAndTime('Creating schemas', 'Created schemas', [false], async () => {
-        const schemas = await generateSchemas(tsconfig, [functions.typesMap, http.typesMap, channels.typesMap], http.meta);
-        await saveSchemas(schemaDirectory, schemas, functions.typesMap, http.meta, supportsImportAttributes);
+        const schemas = await generateSchemas(tsconfig, functions.typesMap, functions.meta, http.meta);
+        await saveSchemas(schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
     });
 };
 async function action({ config }) {

package/dist/src/openapi-spec-generator.d.ts

@@ -1,4 +1,4 @@
-import { HTTPRoutesMeta } from '@pikku/core';
+import { FunctionsMeta, HTTPRoutesMeta } from '@pikku/core';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +75,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

package/dist/src/openapi-spec-generator.js

@@ -9,9 +9,12 @@ const getErrorResponseForConstructorName = (constructorName) => {
     }
     return undefined;
 };
-const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
+const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
     const requiredSchemas = new Set(routesMeta
-        .map(({ inputTypes, output }) => [inputTypes?.body, output])
+        .map(({ inputTypes, pikkuFuncName }) => {
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
+        return [inputTypes?.body, output];
+    })
         .flat()
         .filter((schema) => !!schema));
     const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
@@ -26,10 +29,16 @@ const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
     }));
     return Object.fromEntries(convertedEntries.filter((s) => !!s));
 };
-export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
+export async function generateOpenAPISpec(functionsMeta, routeMeta, schemas, additionalInfo) {
     const paths = {};
     routeMeta.forEach((meta) => {
-        const { route, method, inputTypes, output, params, query, docs } = meta;
+        const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
+            return;
+        }
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
         if (!paths[path]) {
             paths[path] = {};
@@ -103,7 +112,7 @@ export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
         servers: additionalInfo.servers,
         paths,
         components: {
-            schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+            schemas: await convertSchemasToBodyPayloads(functionsMeta, routeMeta, schemas),
             responses: {},
             parameters: {},
             examples: {},

package/dist/src/pikku-cli-config.d.ts

@@ -10,6 +10,7 @@ export interface PikkuCLICoreOutputFiles {
     channelsMetaFile: string;
     schedulersFile: string;
     schedulersMetaFile: string;
+    rpcFile: string;
     schemaDirectory: string;
     typesDeclarationFile: string;
     httpRoutesMapDeclarationFile: string;

package/dist/src/pikku-cli-config.js

@@ -62,6 +62,9 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.functionsMetaFile) {
                 result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
             }
+            if (!result.rpcFile) {
+                result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts');
+            }
             if (!result.httpRoutesFile) {
                 result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts');
             }

package/dist/src/schema-generator.d.ts

@@ -1,5 +1,5 @@
-import { JSONValue } from '@pikku/core';
+import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;
+export declare function generateSchemas(tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema-generator.js

@@ -1,37 +1,18 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
 import { logInfo, writeFileInDir } from './utils.js';
 import { mkdir, writeFile } from 'fs/promises';
-export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
-    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
-    for (const { input, inputTypes } of httpRoutesMeta) {
-        if (input) {
-            let found = false;
-            for (const typesMap of typesMaps) {
-                try {
-                    const uniqueName = typesMap.getUniqueName(input);
-                    if (uniqueName) {
-                        found = true;
-                        schemasSet.add(uniqueName);
-                        break;
-                    }
-                }
-                catch (e) {
-                }
-            }
-            if (!found) {
-                console.error('Input type not found in any types map:', input);
+export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRoutesMeta) {
+    const schemasSet = new Set(typesMap.customTypes.keys());
+    for (const { inputs, outputs } of Object.values(functionMeta)) {
+        const types = [...(inputs || []), ...(outputs || [])];
+        for (const type of types) {
+            const uniqueName = typesMap.getUniqueName(type);
+            if (uniqueName) {
+                schemasSet.add(uniqueName);
             }
         }
-        // if (output) {
-        //   for (const typesMap of typesMaps) {
-        //     const uniqueName = typesMap.getUniqueName(output)
-        //     if (uniqueName) {
-        //       console.log('Adding output schema:', uniqueName)
-        //       schemasSet.add(uniqueName)
-        //       break
-        //     }
-        //   }
-        // }
+    }
+    for (const { inputTypes } of httpRoutesMeta) {
         if (inputTypes?.body) {
             schemasSet.add(inputTypes.body);
         }
@@ -64,13 +45,13 @@ export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
     });
     return schemas;
 }
-export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta, supportsImportAttributes) {
+export async function saveSchemas(schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes) {
     await writeFileInDir(`${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
     const desiredSchemas = new Set([
-        ...routesMeta
-            .map(({ input, output }) => [
-            input ? typesMap.getUniqueName(input) : undefined,
-            output ? typesMap.getUniqueName(output) : undefined,
+        ...Object.values(functionsMeta)
+            .map(({ inputs, outputs }) => [
+            inputs?.[0] ? typesMap.getUniqueName(inputs[0]) : undefined,
+            outputs?.[0] ? typesMap.getUniqueName(outputs[0]) : undefined,
         ])
             .flat()
             .filter((s) => !!s &&

package/dist/src/serialize-typed-function-map.d.ts

@@ -1,4 +1,5 @@
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
 export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/serialize-typed-function-map.js

@@ -1,9 +1,9 @@
 import { serializeImportMap } from './serialize-import-map.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
+export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedRoutes = generateRoutes(functionsMeta, routesMeta, typesMap, requiredTypes);
     const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
@@ -44,11 +44,13 @@ ${Array.from(typesMap.customTypes.entries())
     })
         .join('\n')}`;
 }
-function generateRoutes(routesMeta, typesMap, requiredTypes) {
+function generateRoutes(functionsMeta, routesMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};
     for (const meta of routesMeta) {
-        const { route, method, input, output } = meta;
+        const { route, method, pikkuFuncName } = meta;
+        const input = functionsMeta[pikkuFuncName]?.inputs?.[0];
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
         // Initialize the route entry if it doesn't exist
         if (!routesObj[route]) {
             routesObj[route] = {};

package/dist/src/serialize-typed-http-map.d.ts

@@ -1,4 +1,5 @@
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
 export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/serialize-typed-http-map.js

@@ -1,9 +1,9 @@
 import { serializeImportMap } from './serialize-import-map.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
+export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedRoutes = generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes);
     const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
@@ -44,11 +44,17 @@ ${Array.from(typesMap.customTypes.entries())
     })
         .join('\n')}`;
 }
-function generateRoutes(routesMeta, typesMap, requiredTypes) {
+function generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};
     for (const meta of routesMeta) {
-        const { route, method, input, output } = meta;
+        const { route, method, pikkuFuncName } = meta;
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         // Initialize the route entry if it doesn't exist
         if (!routesObj[route]) {
             routesObj[route] = {};

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-import-map.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-function-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils.ts"],"version":"5.7.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.7.0",
-    "@pikku/inspector": "^0.7.0",
+    "@pikku/core": "^0.7.4",
+    "@pikku/inspector": "^0.7.4",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/inspector-glob.ts

@@ -0,0 +1,28 @@
+import * as path from 'path'
+import { glob } from 'tinyglobby'
+import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
+import { logCommandInfoAndTime } from './utils.js'
+
+export const inspectorGlob = async (
+  rootDir: string,
+  srcDirectories: string[],
+  filters: InspectorFilters
+) => {
+  let result: InspectorState
+  await logCommandInfoAndTime(
+    'Inspecting codebase',
+    'Inspected codebase',
+    [false],
+    async () => {
+      const routeFiles = (
+        await Promise.all(
+          srcDirectories.map((dir) =>
+            glob(`${path.join(rootDir, dir)}/**/*.ts`)
+          )
+        )
+      ).flat()
+      result = await inspect(routeFiles, filters)
+    }
+  )
+  return result!
+}