@pikku/cli 0.6.20 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @pikku/cli
 
+## 0.7.1
+
+### Patch Changes
+
+- 534fdef: feat: adding rpc (locally for now)
+- Updated dependencies [534fdef]
+  - @pikku/inspector@0.7.3
+  - @pikku/core@0.7.3
+
+## 0.7.0
+
+- Now function first. No breaking changes for end user here, just internals
+
 ## 0.6.20
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -7,9 +7,9 @@ import {
   writeFileInDir,
 } from '../src/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuHTTP } from './pikku-http.js'
+import { pikkuHTTP } from './pikku-http-routes.js'
 import { pikkuFunctionTypes } from './pikku-function-types.js'
-import { pikkuHTTPMap } from './pikku-routes-map.js'
+import { pikkuHTTPMap } from './pikku-http-map.js'
 import { existsSync } from 'fs'
 import { pikkuFetch } from './pikku-fetch.js'
 import { pikkuChannelsMap } from './pikku-channels-map.js'
@@ -21,19 +21,25 @@ import { pikkuSchemas } from './pikku-schemas.js'
 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: PikkuCLIConfig, options: PikkuCLIOptions) => {
+  const metaImports: string[] = []
   const imports: string[] = []
-  const addImport = (from: string) => {
-    imports.push(
-      `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
-    )
+  const addImport = (from: string, type: 'meta' | 'events' | 'other') => {
+    const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
+    if (type === 'meta') {
+      metaImports.push(statement)
+    } else {
+      imports.push(statement)
+    }
   }
 
   let typesDeclarationFileExists = true
   let visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
 
@@ -42,38 +48,52 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   }
   await pikkuFunctionTypes(cliConfig, options, visitState)
 
-  // This is needed since the addRoutes function will add the routes to the visitState
+  // This is needed since the addHTTPRoute function will add the routes to the visitState
   if (!typesDeclarationFileExists) {
     logInfo(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
       cliConfig.rootDir,
-      cliConfig.routeDirectories,
+      cliConfig.srcDirectories,
       cliConfig.filters
     )
   }
 
+  const functions = pikkuFunctions(cliConfig, visitState)
+  if (!functions) {
+    logInfo(`• No functions found, skipping remaining steps...\x1b[0m`)
+    process.exit(1)
+  }
+  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)
     await pikkuFetch(cliConfig)
-    addImport(cliConfig.routesFile)
+    addImport(cliConfig.httpRoutesMetaFile, 'meta')
+    addImport(cliConfig.httpRoutesFile, 'events')
   }
 
   const scheduled = await pikkuScheduler(cliConfig, visitState)
   if (scheduled) {
-    addImport(cliConfig.schedulersFile)
+    addImport(cliConfig.schedulersMetaFile, 'meta')
+    addImport(cliConfig.schedulersFile, 'events')
   }
 
   const channels = await pikkuChannels(cliConfig, visitState)
   if (channels) {
     await pikkuChannelsMap(cliConfig, visitState)
     await pikkuWebSocket(cliConfig)
-    addImport(cliConfig.channelsFile)
+    addImport(cliConfig.channelsMetaFile, 'meta')
+    addImport(cliConfig.channelsFile, 'events')
   }
 
   const schemas = await pikkuSchemas(cliConfig, visitState)
   if (schemas) {
-    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`)
+    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
   }
 
   if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
@@ -84,17 +104,20 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
     logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
     visitState = await inspectorGlob(
       cliConfig.rootDir,
-      cliConfig.routeDirectories,
+      cliConfig.srcDirectories,
       cliConfig.filters
     )
     await pikkuOpenAPI(cliConfig, visitState)
   }
 
-  await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'))
+  await writeFileInDir(
+    cliConfig.bootstrapFile,
+    [...metaImports, ...imports].join('\n')
+  )
 }
 
 const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
-  const configWatcher = chokidar.watch(cliConfig.routeDirectories, {
+  const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
     ignoreInitial: true,
     ignored: /.*\.gen\.tsx?/,
   })
@@ -105,9 +128,9 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
     watcher.close()
 
     logInfo(
-      `• Watching directories: \n  - ${cliConfig.routeDirectories.join('\n  - ')}`
+      `• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`
     )
-    watcher = chokidar.watch(cliConfig.routeDirectories, {
+    watcher = chokidar.watch(cliConfig.srcDirectories, {
       ignoreInitial: true,
       ignored: /.*\.gen\.ts/,
     })

package/bin/pikku-channels-map.ts

@@ -7,7 +7,7 @@ import {
   PikkuCLIOptions,
   writeFileInDir,
 } from '../src/utils.js'
-import { serializeTypedChannelsMap } from '../src/channels/serialize-typed-channel-map.js'
+import { serializeTypedChannelsMap } from '../src/serialize-typed-channel-map.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuChannelsMap = async (
@@ -22,7 +22,7 @@ export const pikkuChannelsMap = async (
       const content = serializeTypedChannelsMap(
         channelsMapDeclarationFile,
         packageMappings,
-        state.channels.typesMap,
+        state.functions.typesMap,
         state.channels.meta
       )
       await writeFileInDir(channelsMapDeclarationFile, content)
@@ -34,13 +34,13 @@ async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
   const cliConfig = await getPikkuCLIConfig(
     cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
     cliOptions.tags,
     false
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuChannelsMap(cliConfig, visitState)

package/bin/pikku-channels.ts

@@ -5,12 +5,9 @@ import {
   logCommandInfoAndTime,
   logPikkuLogo,
   PikkuCLIOptions,
+  serializeFileImports,
   writeFileInDir,
 } from '../src/utils.js'
-import {
-  serializeChannels,
-  serializeChannelMeta,
-} from '../src/channels/serialize-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuChannels = async (
@@ -22,13 +19,21 @@ export const pikkuChannels = async (
     'Found channels',
     [visitState.channels.files.size === 0],
     async () => {
-      const { channelsFile, packageMappings } = cliConfig
+      const { channelsFile, channelsMetaFile, packageMappings } = cliConfig
       const { channels } = visitState
-      const content = [
-        serializeChannels(channelsFile, channels.files, packageMappings),
-        serializeChannelMeta(channels.meta),
-      ]
-      await writeFileInDir(channelsFile, content.join('\n\n'))
+      await writeFileInDir(
+        channelsFile,
+        serializeFileImports(
+          'addChannel',
+          channelsFile,
+          channels.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        channelsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
+      )
     }
   )
 }
@@ -38,12 +43,12 @@ async function action(cliOptions: PikkuCLIOptions): Promise<void> {
 
   const cliConfig = await getPikkuCLIConfig(
     cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
     cliOptions.tags
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuChannels(cliConfig, visitState)

package/bin/pikku-fetch.ts

@@ -7,11 +7,11 @@ import {
   writeFileInDir,
 } from '../src/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeFetchWrapper } from '../src/http/serialize-fetch-wrapper.js'
+import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js'
 
 export const pikkuFetch = async ({
   fetchFile,
-  routesMapDeclarationFile,
+  httpRoutesMapDeclarationFile,
   packageMappings,
 }: PikkuCLIConfig) => {
   await logCommandInfoAndTime(
@@ -25,7 +25,7 @@ export const pikkuFetch = async ({
 
       const routesMapDeclarationPath = getFileImportRelativePath(
         fetchFile,
-        routesMapDeclarationFile,
+        httpRoutesMapDeclarationFile,
         packageMappings
       )
 

package/bin/pikku-function-types.ts

@@ -9,9 +9,9 @@ import {
   PikkuCLIOptions,
   writeFileInDir,
 } from '../src/utils.js'
-import { pikkuHTTP } from './pikku-http.js'
+import { pikkuHTTP } from './pikku-http-routes.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-import { serializePikkuTypes } from '../src/core/serialize-pikku-types.js'
+import { serializePikkuTypes } from '../src/serialize-pikku-types.js'
 
 export const pikkuFunctionTypes = async (
   { typesDeclarationFile: typesFile, packageMappings }: PikkuCLIConfig,
@@ -54,13 +54,13 @@ async function action(cliOptions: PikkuCLIOptions): Promise<void> {
 
   const cliConfig = await getPikkuCLIConfig(
     cliOptions.config,
-    ['rootDir', 'routeDirectories', 'typesDeclarationFile'],
+    ['rootDir', 'srcDirectories', 'typesDeclarationFile'],
     cliOptions.tags
   )
 
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuHTTP(cliConfig, visitState)

package/bin/pikku-functions.ts

@@ -0,0 +1,35 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../src/utils.js'
+
+export const pikkuFunctions = async (
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  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('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+      )
+    }
+  )
+}

package/bin/{pikku-routes-map.ts → pikku-http-map.ts}

@@ -7,26 +7,26 @@ import {
   PikkuCLIOptions,
   writeFileInDir,
 } from '../src/utils.js'
-import { serializeTypedRoutesMap } from '../src/http/serialize-typed-route-map.js'
+import { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuHTTPMap = async (
-  { routesMapDeclarationFile, packageMappings }: PikkuCLIConfig,
-  { http }: InspectorState
+  { httpRoutesMapDeclarationFile, packageMappings }: PikkuCLIConfig,
+  { http, functions }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
-    'Creating routes map',
-    'Created routes map',
+    'Creating HTTP map',
+    'Created HTTP map',
     [http.files.size === 0],
     async () => {
       const content = serializeTypedRoutesMap(
-        routesMapDeclarationFile,
+        httpRoutesMapDeclarationFile,
         packageMappings,
-        http.typesMap,
+        functions.typesMap,
         http.meta,
         http.metaInputTypes
       )
-      await writeFileInDir(routesMapDeclarationFile, content)
+      await writeFileInDir(httpRoutesMapDeclarationFile, content)
     }
   )
 }
@@ -35,12 +35,12 @@ async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
   const cliConfig = await getPikkuCLIConfig(
     cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
     cliOptions.tags
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuHTTPMap(cliConfig, visitState)

package/bin/{pikku-http.ts → pikku-http-routes.ts}

@@ -1,14 +1,13 @@
 import { Command } from 'commander'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeHTTPRoutesMeta } from '../src/http/serialize-route-meta.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
   logPikkuLogo,
   PikkuCLIOptions,
+  serializeFileImports,
   writeFileInDir,
 } from '../src/utils.js'
-import { serializeRoutes } from '../src/http/serialize-route-imports.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuHTTP = async (
@@ -20,13 +19,21 @@ export const pikkuHTTP = async (
     'Found HTTP routes',
     [visitState.http.files.size === 0],
     async () => {
-      const { routesFile, packageMappings } = cliConfig
+      const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
       const { http } = visitState
-      const content = [
-        serializeRoutes(routesFile, http.files, packageMappings),
-        serializeHTTPRoutesMeta(http.meta),
-      ]
-      await writeFileInDir(routesFile, content.join('\n\n'))
+      await writeFileInDir(
+        httpRoutesFile,
+        serializeFileImports(
+          'addHTTPRoute',
+          httpRoutesFile,
+          http.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        httpRoutesMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      )
     }
   )
 }
@@ -36,12 +43,12 @@ async function action(cliOptions: PikkuCLIOptions): Promise<void> {
 
   const cliConfig = await getPikkuCLIConfig(
     cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
     cliOptions.tags
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuHTTP(cliConfig, visitState)

package/bin/pikku-nextjs.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/nextjs/serialize-nextjs-backend-wrapper.js'
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/nextjs/serialize-nextjs-http-wrapper.js'
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/serialize-nextjs-backend-wrapper.js'
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/serialize-nextjs-http-wrapper.js'
 import {
   getFileImportRelativePath,
   getPikkuFilesAndMethods,
@@ -17,8 +17,8 @@ export const pikkuNext = async (
   {
     nextBackendFile,
     nextHTTPFile,
-    routesFile,
-    routesMapDeclarationFile,
+    httpRoutesFile,
+    httpRoutesMapDeclarationFile,
     schemaDirectory,
     packageMappings,
     fetchFile,
@@ -69,13 +69,13 @@ export const pikkuNext = async (
 
         const routesPath = getFileImportRelativePath(
           nextBackendFile,
-          routesFile,
+          httpRoutesFile,
           packageMappings
         )
 
         const routesMapDeclarationPath = getFileImportRelativePath(
           nextBackendFile,
-          routesMapDeclarationFile,
+          httpRoutesMapDeclarationFile,
           packageMappings
         )
         const schemasPath = getFileImportRelativePath(
@@ -98,13 +98,13 @@ export const pikkuNext = async (
       if (nextHTTPFile) {
         const routesPath = getFileImportRelativePath(
           nextHTTPFile,
-          routesFile,
+          httpRoutesFile,
           packageMappings
         )
 
         const routesMapDeclarationPath = getFileImportRelativePath(
           nextHTTPFile,
-          routesMapDeclarationFile,
+          httpRoutesMapDeclarationFile,
           packageMappings
         )
 
@@ -128,7 +128,7 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuNext(cliConfig, visitState, options)

package/bin/pikku-openapi.ts

@@ -5,8 +5,8 @@ import {
   PikkuCLIOptions,
   writeFileInDir,
 } from '../src/utils.js'
-import { generateSchemas } from '../src/schema/schema-generator.js'
-import { generateOpenAPISpec } from '../src/openapi/openapi-spec-generator.js'
+import { generateSchemas } from '../src/schema-generator.js'
+import { generateOpenAPISpec } from '../src/openapi-spec-generator.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import { stringify } from 'yaml'
@@ -14,7 +14,7 @@ import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuOpenAPI = async (
   { tsconfig, openAPI }: PikkuCLIConfig,
-  { http }: InspectorState
+  { http, functions }: InspectorState
 ) => {
   await logCommandInfoAndTime(
     'Creating OpenAPI spec',
@@ -24,7 +24,11 @@ export const pikkuOpenAPI = async (
       if (!openAPI?.outputFile) {
         throw new Error('openAPI is required')
       }
-      const schemas = await generateSchemas(tsconfig, http.typesMap, http.meta)
+      const schemas = await generateSchemas(
+        tsconfig,
+        [http.typesMap, functions.typesMap],
+        http.meta
+      )
       const openAPISpec = await generateOpenAPISpec(
         http.meta,
         schemas,
@@ -50,12 +54,12 @@ async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
   const cliConfig = await getPikkuCLIConfig(
     config,
-    ['rootDir', 'routesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
+    ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
     tags
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuOpenAPI(cliConfig, visitState)

package/bin/pikku-rpc.ts

@@ -0,0 +1,22 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils.js'
+
+export const pikkuRPC = async (
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  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/bin/pikku-scheduler.ts

@@ -5,12 +5,10 @@ import {
   logCommandInfoAndTime,
   logPikkuLogo,
   PikkuCLIOptions,
+  serializeFileImports,
   writeFileInDir,
 } from '../src/utils.js'
-import {
-  serializeSchedulerMeta,
-  serializeSchedulers,
-} from '../src/scheduler/serialize-schedulers.js'
+import { serializeSchedulerMeta } from '../src/serialize-scheduler-meta.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuScheduler = async (
@@ -22,17 +20,21 @@ export const pikkuScheduler = async (
     'Found scheduled tasks',
     [visitState.scheduledTasks.files.size === 0],
     async () => {
-      const { schedulersFile, packageMappings } = cliConfig
+      const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig
       const { scheduledTasks } = visitState
-      const content = [
-        serializeSchedulers(
+      await writeFileInDir(
+        schedulersMetaFile,
+        serializeSchedulerMeta(scheduledTasks.meta)
+      )
+      await writeFileInDir(
+        schedulersFile,
+        serializeFileImports(
+          'addSerializedTasks',
           schedulersFile,
           scheduledTasks.files,
           packageMappings
-        ),
-        serializeSchedulerMeta(scheduledTasks.meta),
-      ]
-      await writeFileInDir(schedulersFile, content.join('\n\n'))
+        )
+      )
     }
   )
 }
@@ -42,12 +44,12 @@ async function action(options: PikkuCLIOptions): Promise<void> {
 
   const cliConfig = await getPikkuCLIConfig(
     options.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
     options.tags
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories,
+    cliConfig.srcDirectories,
     cliConfig.filters
   )
   await pikkuScheduler(cliConfig, visitState)