@pikku/inspector 0.9.5 → 0.10.0

package/dist/add-mcp-resource.d.ts

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

package/dist/add-mcp-resource.js

@@ -1,68 +0,0 @@
-import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addMCPResource = (node, checker, state, filters, logger) => {
-    if (!ts.isCallExpression(node)) {
-        return;
-    }
-    const args = node.arguments;
-    const firstArg = args[0];
-    const expression = node.expression;
-    // Check if the call is to wireMCPResource
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPResource') {
-        return;
-    }
-    if (!firstArg) {
-        return;
-    }
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        const uriValue = getPropertyValue(obj, 'uri');
-        const titleValue = getPropertyValue(obj, 'title');
-        const descriptionValue = getPropertyValue(obj, 'description');
-        const streamingValue = getPropertyValue(obj, 'streaming');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
-        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
-        if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP resource '${uriValue}'.`);
-            return;
-        }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
-        if (!uriValue) {
-            console.error(`• MCP resource is missing the required 'uri' property.`);
-            return;
-        }
-        if (!titleValue) {
-            console.error(`• MCP resource '${uriValue}' is missing the required 'title' property.`);
-            return;
-        }
-        if (!descriptionValue) {
-            console.error(`• MCP resource '${uriValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.mcp, name: uriValue, filePath }, logger)) {
-            return;
-        }
-        // lookup existing function metadata
-        const fnMeta = state.functions.meta[pikkuFuncName];
-        if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
-            return;
-        }
-        const inputSchema = fnMeta.inputs?.[0] || null;
-        const outputSchema = fnMeta.outputs?.[0] || null;
-        state.mcpEndpoints.files.add(node.getSourceFile().fileName);
-        state.mcpEndpoints.resourcesMeta[uriValue] = {
-            pikkuFuncName,
-            uri: uriValue,
-            title: titleValue,
-            description: descriptionValue,
-            ...(streamingValue !== null && { streaming: streamingValue }),
-            tags,
-            inputSchema,
-            outputSchema,
-        };
-    }
-};

package/dist/add-mcp-tool.d.ts

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

package/dist/add-mcp-tool.js

@@ -1,64 +0,0 @@
-import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addMCPTool = (node, checker, state, filters, logger) => {
-    if (!ts.isCallExpression(node)) {
-        return;
-    }
-    const args = node.arguments;
-    const firstArg = args[0];
-    const expression = node.expression;
-    // Check if the call is to wireMCPTool
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPTool') {
-        return;
-    }
-    if (!firstArg) {
-        return;
-    }
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        const nameValue = getPropertyValue(obj, 'name');
-        const titleValue = getPropertyValue(obj, 'title');
-        const descriptionValue = getPropertyValue(obj, 'description');
-        const streamingValue = getPropertyValue(obj, 'streaming');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
-        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
-        if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP tool '${nameValue}'.`);
-            return;
-        }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
-        if (!nameValue) {
-            console.error(`• MCP tool is missing the required 'name' property.`);
-            return;
-        }
-        if (!descriptionValue) {
-            console.error(`• MCP tool '${nameValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
-            return;
-        }
-        // lookup existing function metadata
-        const fnMeta = state.functions.meta[pikkuFuncName];
-        if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
-            return;
-        }
-        const inputSchema = fnMeta.inputs?.[0] || null;
-        const outputSchema = fnMeta.outputs?.[0] || null;
-        state.mcpEndpoints.files.add(node.getSourceFile().fileName);
-        state.mcpEndpoints.toolsMeta[nameValue] = {
-            pikkuFuncName,
-            name: nameValue,
-            title: titleValue || undefined,
-            description: descriptionValue,
-            ...(streamingValue !== null && { streaming: streamingValue }),
-            tags,
-            inputSchema,
-            outputSchema,
-        };
-    }
-};

package/dist/add-middleware.d.ts

@@ -1,7 +0,0 @@
-import * as ts from 'typescript';
-import { InspectorLogger, InspectorState } from './types.js';
-/**
- * Inspect pikkuMiddleware calls and extract first-arg destructuring
- * for tree shaking optimization.
- */
-export declare function addMiddleware(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, logger: InspectorLogger): void;

package/dist/add-middleware.js

@@ -1,35 +0,0 @@
-import * as ts from 'typescript';
-import { extractFunctionName, extractServicesFromFunction } from './utils.js';
-/**
- * Inspect pikkuMiddleware calls and extract first-arg destructuring
- * for tree shaking optimization.
- */
-export function addMiddleware(node, checker, state, logger) {
-    if (!ts.isCallExpression(node))
-        return;
-    const { expression, arguments: args } = node;
-    // only handle calls like pikkuMiddleware(...)
-    if (!ts.isIdentifier(expression)) {
-        return;
-    }
-    if (expression.text !== 'pikkuMiddleware') {
-        return;
-    }
-    const handlerNode = args[0];
-    if (!handlerNode)
-        return;
-    if (!ts.isArrowFunction(handlerNode) &&
-        !ts.isFunctionExpression(handlerNode)) {
-        logger.error(`• Handler for pikkuMiddleware is not a function.`);
-        return;
-    }
-    const services = extractServicesFromFunction(handlerNode);
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
-    state.middleware.meta[pikkuFuncName] = {
-        services,
-        sourceFile: node.getSourceFile().fileName,
-        position: node.getStart(),
-        exportedName,
-    };
-    logger.debug(`• Found middleware with services: ${services.services.join(', ')}`);
-}

package/dist/add-permission.d.ts

@@ -1,7 +0,0 @@
-import * as ts from 'typescript';
-import { InspectorLogger, InspectorState } from './types.js';
-/**
- * Inspect pikkuPermission calls and extract first-arg destructuring
- * for tree shaking optimization.
- */
-export declare function addPermission(node: ts.Node, checker: ts.TypeChecker, state: InspectorState, logger: InspectorLogger): void;

package/dist/add-permission.js

@@ -1,35 +0,0 @@
-import * as ts from 'typescript';
-import { extractFunctionName, extractServicesFromFunction } from './utils.js';
-/**
- * Inspect pikkuPermission calls and extract first-arg destructuring
- * for tree shaking optimization.
- */
-export function addPermission(node, checker, state, logger) {
-    if (!ts.isCallExpression(node))
-        return;
-    const { expression, arguments: args } = node;
-    // only handle calls like pikkuPermission(...)
-    if (!ts.isIdentifier(expression)) {
-        return;
-    }
-    if (expression.text !== 'pikkuPermission') {
-        return;
-    }
-    const handlerNode = args[0];
-    if (!handlerNode)
-        return;
-    if (!ts.isArrowFunction(handlerNode) &&
-        !ts.isFunctionExpression(handlerNode)) {
-        logger.error(`• Handler for pikkuPermission is not a function.`);
-        return;
-    }
-    const services = extractServicesFromFunction(handlerNode);
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
-    state.permissions.meta[pikkuFuncName] = {
-        services,
-        sourceFile: node.getSourceFile().fileName,
-        position: node.getStart(),
-        exportedName,
-    };
-    logger.debug(`• Found permission with services: ${services.services.join(', ')}`);
-}

package/dist/add-queue-worker.d.ts

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

package/dist/add-queue-worker.js

@@ -1,48 +0,0 @@
-import * as ts from 'typescript';
-import { getPropertyValue } from './get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
-import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
-export const addQueueWorker = (node, checker, state, filters, logger) => {
-    if (!ts.isCallExpression(node)) {
-        return;
-    }
-    const args = node.arguments;
-    const firstArg = args[0];
-    const expression = node.expression;
-    // Check if the call is to addQueueWorker
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireQueueWorker') {
-        return;
-    }
-    if (!firstArg) {
-        return;
-    }
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        const queueName = getPropertyValue(obj, 'queueName');
-        const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyValue(obj, 'tags') || undefined;
-        // --- find the referenced function ---
-        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
-        if (!funcInitializer) {
-            console.error(`• No valid 'func' property for queue processor '${queueName}'.`);
-            return;
-        }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
-        if (!queueName) {
-            console.error(`• No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.queue, name: queueName, filePath }, logger)) {
-            console.info(`• Skipping queue processor '${pikkuFuncName}' for queue '${queueName}' due to filter mismatch.`);
-            return;
-        }
-        state.queueWorkers.files.add(node.getSourceFile().fileName);
-        state.queueWorkers.meta[queueName] = {
-            pikkuFuncName,
-            queueName,
-            docs,
-            tags,
-        };
-    }
-};

package/dist/add-schedule.d.ts

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

package/dist/get-property-value.d.ts

@@ -1,3 +0,0 @@
-import { PikkuDocs } from '@pikku/core';
-import * as ts from 'typescript';
-export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | PikkuDocs | boolean;

package/dist/utils.d.ts

@@ -1,39 +0,0 @@
-import * as ts from 'typescript';
-import { InspectorFilters, InspectorLogger } from './types.js';
-import { PikkuWiringTypes, FunctionServicesMeta } from '@pikku/core';
-type ExtractedFunctionName = {
-    pikkuFuncName: string;
-    name: string;
-    explicitName: string | null;
-    exportedName: string | null;
-    localName: string | null;
-    propertyName: string | null;
-};
-/**
- * Generate a deterministic "anonymous" name for any expression node,
- * but if it's an Identifier pointing to a function, resolve it back
- * to the function's declaration (so you get the true source location).
- */
-export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.TypeChecker): string;
-/**
- * Updated function to extract and prioritize function names correctly
- * This function follows the priority:
- * 1. Object with a name property
- * 2. Exported name
- * 3. Fallback to deterministic name
- */
-export declare function extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker): ExtractedFunctionName;
-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;
-export declare const matchesFilters: (filters: InspectorFilters, params: {
-    tags?: string[];
-}, meta: {
-    type: PikkuWiringTypes;
-    name: string;
-    filePath?: string;
-}, logger: InspectorLogger) => boolean;
-/**
- * Extract services from a function's first parameter destructuring pattern
- */
-export declare function extractServicesFromFunction(handlerNode: ts.FunctionExpression | ts.ArrowFunction): FunctionServicesMeta;
-export {};

package/src/add-mcp-prompt.ts

@@ -1,104 +0,0 @@
-import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { PikkuWiringTypes } from '@pikku/core'
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
-
-export const addMCPPrompt = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to wireMCPPrompt
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPPrompt') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const nameValue = getPropertyValue(obj, 'name') as string | null
-    const descriptionValue = getPropertyValue(obj, 'description') as
-      | string
-      | null
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    const funcInitializer = getPropertyAssignmentInitializer(
-      obj,
-      'func',
-      true,
-      checker
-    )
-    if (!funcInitializer) {
-      console.error(`• No valid 'func' property for MCP prompt '${nameValue}'.`)
-      return
-    }
-
-    const pikkuFuncName = extractFunctionName(
-      funcInitializer,
-      checker
-    ).pikkuFuncName
-
-    if (!nameValue) {
-      console.error(`• MCP prompt is missing the required 'name' property.`)
-      return
-    }
-
-    if (!descriptionValue) {
-      console.error(`• MCP prompt '${nameValue}' is missing a description.`)
-      return
-    }
-
-    const filePath = node.getSourceFile().fileName
-
-    if (
-      !matchesFilters(
-        filters,
-        { tags },
-        { type: PikkuWiringTypes.mcp, name: nameValue, filePath },
-        logger
-      )
-    ) {
-      return
-    }
-
-    // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncName]
-    if (!fnMeta) {
-      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
-      return
-    }
-    const inputSchema = fnMeta.inputs?.[0] || null
-    const outputSchema = fnMeta.outputs?.[0] || null
-
-    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
-
-    state.mcpEndpoints.promptsMeta[nameValue] = {
-      pikkuFuncName,
-      name: nameValue,
-      description: descriptionValue,
-      tags,
-      inputSchema,
-      outputSchema,
-      arguments: [], // Will be populated by CLI during serialization
-    }
-  }
-}

package/src/add-mcp-resource.ts

@@ -1,116 +0,0 @@
-import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { PikkuWiringTypes } from '@pikku/core'
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
-
-export const addMCPResource = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to wireMCPResource
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPResource') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const uriValue = getPropertyValue(obj, 'uri') as string | null
-    const titleValue = getPropertyValue(obj, 'title') as string | null
-    const descriptionValue = getPropertyValue(obj, 'description') as
-      | string
-      | null
-    const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    const funcInitializer = getPropertyAssignmentInitializer(
-      obj,
-      'func',
-      true,
-      checker
-    )
-    if (!funcInitializer) {
-      console.error(
-        `• No valid 'func' property for MCP resource '${uriValue}'.`
-      )
-      return
-    }
-
-    const pikkuFuncName = extractFunctionName(
-      funcInitializer,
-      checker
-    ).pikkuFuncName
-
-    if (!uriValue) {
-      console.error(`• MCP resource is missing the required 'uri' property.`)
-      return
-    }
-
-    if (!titleValue) {
-      console.error(
-        `• MCP resource '${uriValue}' is missing the required 'title' property.`
-      )
-      return
-    }
-
-    if (!descriptionValue) {
-      console.error(`• MCP resource '${uriValue}' is missing a description.`)
-      return
-    }
-
-    const filePath = node.getSourceFile().fileName
-
-    if (
-      !matchesFilters(
-        filters,
-        { tags },
-        { type: PikkuWiringTypes.mcp, name: uriValue, filePath },
-        logger
-      )
-    ) {
-      return
-    }
-
-    // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncName]
-    if (!fnMeta) {
-      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
-      return
-    }
-    const inputSchema = fnMeta.inputs?.[0] || null
-    const outputSchema = fnMeta.outputs?.[0] || null
-
-    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
-
-    state.mcpEndpoints.resourcesMeta[uriValue] = {
-      pikkuFuncName,
-      uri: uriValue,
-      title: titleValue,
-      description: descriptionValue,
-      ...(streamingValue !== null && { streaming: streamingValue }),
-      tags,
-      inputSchema,
-      outputSchema,
-    }
-  }
-}

package/src/add-mcp-tool.ts

@@ -1,107 +0,0 @@
-import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { PikkuWiringTypes } from '@pikku/core'
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
-
-export const addMCPTool = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to wireMCPTool
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPTool') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const nameValue = getPropertyValue(obj, 'name') as string | null
-    const titleValue = getPropertyValue(obj, 'title') as string | null
-    const descriptionValue = getPropertyValue(obj, 'description') as
-      | string
-      | null
-    const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    const funcInitializer = getPropertyAssignmentInitializer(
-      obj,
-      'func',
-      true,
-      checker
-    )
-    if (!funcInitializer) {
-      console.error(`• No valid 'func' property for MCP tool '${nameValue}'.`)
-      return
-    }
-
-    const pikkuFuncName = extractFunctionName(
-      funcInitializer,
-      checker
-    ).pikkuFuncName
-
-    if (!nameValue) {
-      console.error(`• MCP tool is missing the required 'name' property.`)
-      return
-    }
-
-    if (!descriptionValue) {
-      console.error(`• MCP tool '${nameValue}' is missing a description.`)
-      return
-    }
-
-    const filePath = node.getSourceFile().fileName
-
-    if (
-      !matchesFilters(
-        filters,
-        { tags },
-        { type: PikkuWiringTypes.mcp, name: nameValue, filePath },
-        logger
-      )
-    ) {
-      return
-    }
-
-    // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncName]
-    if (!fnMeta) {
-      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
-      return
-    }
-    const inputSchema = fnMeta.inputs?.[0] || null
-    const outputSchema = fnMeta.outputs?.[0] || null
-
-    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
-
-    state.mcpEndpoints.toolsMeta[nameValue] = {
-      pikkuFuncName,
-      name: nameValue,
-      title: titleValue || undefined,
-      description: descriptionValue,
-      ...(streamingValue !== null && { streaming: streamingValue }),
-      tags,
-      inputSchema,
-      outputSchema,
-    }
-  }
-}