@pikku/inspector 0.11.0 → 0.11.2

package/dist/utils/extract-function-node.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+/**
+ * Extracts the actual function node from a pikkuFunc/pikkuWorkflowFunc call
+ * Handles both direct function form and config object form { func: ... }
+ */
+export declare function extractFunctionNode(firstArg: ts.Expression, checker: ts.TypeChecker): {
+    funcNode: ts.Node;
+    resolvedFunc: ts.Node | null;
+    isDirectFunction: boolean;
+};

package/dist/utils/extract-function-node.js

@@ -0,0 +1,38 @@
+import * as ts from 'typescript';
+import { getPropertyAssignmentInitializer, resolveFunctionDeclaration, } from './type-utils.js';
+/**
+ * Extracts the actual function node from a pikkuFunc/pikkuWorkflowFunc call
+ * Handles both direct function form and config object form { func: ... }
+ */
+export function extractFunctionNode(firstArg, checker) {
+    let funcNode = firstArg;
+    let isDirectFunction = true;
+    // Check if first argument is a config object with 'func' property
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        isDirectFunction = false;
+        const funcInitializer = getPropertyAssignmentInitializer(firstArg, 'func', true, checker);
+        if (funcInitializer) {
+            funcNode = funcInitializer;
+        }
+        else {
+            // Return the original node if no func property found
+            // Caller should handle validation
+            funcNode = firstArg;
+        }
+    }
+    // Resolve identifier to get the actual function node
+    if (ts.isIdentifier(funcNode)) {
+        const symbol = checker.getSymbolAtLocation(funcNode);
+        const decl = symbol?.valueDeclaration || symbol?.declarations?.[0];
+        if (decl && ts.isVariableDeclaration(decl) && decl.initializer) {
+            funcNode = decl.initializer;
+        }
+    }
+    // Resolve function declaration for deeper analysis
+    const resolvedFunc = resolveFunctionDeclaration(funcNode, checker);
+    return {
+        funcNode,
+        resolvedFunc,
+        isDirectFunction,
+    };
+}

package/dist/utils/extract-node-value.d.ts

@@ -22,3 +22,11 @@ export declare function extractNumberLiteral(node: ts.Node): number | null;
  * Returns the extracted value or null if not found/cannot extract
  */
 export declare function extractPropertyString(objNode: ts.ObjectLiteralExpression, propertyName: string, checker: ts.TypeChecker): string | null;
+/**
+ * Extract description from options object
+ */
+export declare function extractDescription(optionsNode: ts.Node | undefined, checker: ts.TypeChecker): string | null;
+/**
+ * Extract duration value (number or string)
+ */
+export declare function extractDuration(node: ts.Node, checker: ts.TypeChecker): string | number | null;

package/dist/utils/extract-node-value.js

@@ -77,3 +77,27 @@ export function extractPropertyString(objNode, propertyName, checker) {
     }
     return null;
 }
+/**
+ * Extract description from options object
+ */
+export function extractDescription(optionsNode, checker) {
+    if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
+        return null;
+    }
+    return extractPropertyString(optionsNode, 'description', checker);
+}
+/**
+ * Extract duration value (number or string)
+ */
+export function extractDuration(node, checker) {
+    const numValue = extractNumberLiteral(node);
+    if (numValue !== null) {
+        return numValue;
+    }
+    try {
+        return extractStringLiteral(node, checker);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/extract-service-metadata.d.ts

@@ -0,0 +1,19 @@
+import * as ts from 'typescript';
+export interface ServiceMetadata {
+    name: string;
+    summary: string;
+    description: string;
+    package: string;
+    path: string;
+    version: string;
+    interface: string;
+    expandedProperties: Record<string, string>;
+}
+/**
+ * Extract metadata for a service from its TypeScript declaration
+ */
+export declare function extractServiceMetadata(serviceName: string, type: ts.Type, checker: ts.TypeChecker, rootDir: string): ServiceMetadata | null;
+/**
+ * Extract metadata for all services in a type
+ */
+export declare function extractAllServiceMetadata(servicesType: ts.Type, checker: ts.TypeChecker, rootDir: string): ServiceMetadata[];

package/dist/utils/extract-service-metadata.js

@@ -0,0 +1,244 @@
+import * as ts from 'typescript';
+import * as path from 'path';
+import * as fs from 'fs';
+/**
+ * Extract JSDoc comment information from a TypeScript node
+ */
+function extractJSDoc(node) {
+    const jsDocTags = ts.getJSDocTags(node);
+    const jsDocComments = ts.getJSDocCommentsAndTags(node);
+    let summary = '';
+    let description = '';
+    const summaryTag = jsDocTags.find((tag) => tag.tagName.text === 'summary');
+    if (summaryTag && summaryTag.comment) {
+        summary =
+            typeof summaryTag.comment === 'string'
+                ? summaryTag.comment
+                : summaryTag.comment.map((c) => c.text).join('');
+    }
+    for (const comment of jsDocComments) {
+        if (ts.isJSDoc(comment) && comment.comment) {
+            const commentText = typeof comment.comment === 'string'
+                ? comment.comment
+                : comment.comment.map((c) => c.text).join('');
+            if (!summary && commentText) {
+                const lines = commentText
+                    .split('\n')
+                    .map((l) => l.trim())
+                    .filter(Boolean);
+                if (lines.length > 0) {
+                    summary = lines[0];
+                    if (lines.length > 1) {
+                        description = lines.slice(1).join('\n').trim();
+                    }
+                }
+            }
+            else {
+                description = commentText;
+            }
+            break;
+        }
+    }
+    return { summary, description };
+}
+/**
+ * Serialize a TypeScript type to a string representation
+ */
+function serializeTypeToString(node, sourceFile, checker) {
+    const nodeSourceFile = node.getSourceFile();
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+        return node.getText(nodeSourceFile);
+    }
+    if (ts.isClassDeclaration(node)) {
+        return serializePublicClassMembers(node, nodeSourceFile, checker);
+    }
+    const type = checker.getTypeAtLocation(node);
+    return checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
+}
+/**
+ * Extract public members from a class and serialize them
+ */
+function serializePublicClassMembers(classNode, sourceFile, checker) {
+    const className = classNode.name?.text || 'UnnamedClass';
+    const publicMembers = [];
+    for (const member of classNode.members) {
+        const modifiers = ts.canHaveModifiers(member)
+            ? ts.getModifiers(member)
+            : undefined;
+        const isPublic = !modifiers?.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword ||
+            mod.kind === ts.SyntaxKind.ProtectedKeyword);
+        if (!isPublic)
+            continue;
+        if (ts.isMethodDeclaration(member) ||
+            ts.isPropertyDeclaration(member) ||
+            ts.isConstructorDeclaration(member)) {
+            const memberSignature = getMemberSignature(member, sourceFile, checker);
+            if (memberSignature) {
+                publicMembers.push(memberSignature);
+            }
+        }
+    }
+    return `class ${className} {\n  ${publicMembers.join('\n  ')}\n}`;
+}
+/**
+ * Extract a clean signature for a class member (without implementation)
+ */
+function getMemberSignature(member, sourceFile, checker) {
+    if (ts.isPropertyDeclaration(member)) {
+        const name = member.name.getText(sourceFile);
+        const type = member.type ? member.type.getText(sourceFile) : 'any';
+        const optional = member.questionToken ? '?' : '';
+        return `${name}${optional}: ${type};`;
+    }
+    if (ts.isMethodDeclaration(member)) {
+        const name = member.name.getText(sourceFile);
+        const typeParams = member.typeParameters
+            ? `<${member.typeParameters.map((tp) => tp.getText(sourceFile)).join(', ')}>`
+            : '';
+        const params = member.parameters
+            .map((p) => p.getText(sourceFile))
+            .join(', ');
+        const returnType = member.type ? member.type.getText(sourceFile) : 'void';
+        const optional = member.questionToken ? '?' : '';
+        return `${name}${optional}${typeParams}(${params}): ${returnType};`;
+    }
+    if (ts.isConstructorDeclaration(member)) {
+        const params = member.parameters
+            .map((p) => p.getText(sourceFile))
+            .join(', ');
+        return `constructor(${params});`;
+    }
+    return null;
+}
+/**
+ * Find the nearest package.json and extract package name and version
+ */
+function getPackageInfo(filePath) {
+    let currentDir = path.dirname(filePath);
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                return {
+                    packageName: packageJson.name || 'unknown',
+                    version: packageJson.version || '0.0.0',
+                };
+            }
+            catch (err) {
+                // If we can't parse the package.json, continue searching
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return { packageName: 'unknown', version: '0.0.0' };
+}
+/**
+ * Expand a type to show all its properties including inherited ones
+ * Returns a Record mapping property names to their type strings
+ */
+function expandInterfaceProperties(type, checker, maxDepth = 2, currentDepth = 0, visited = new Set()) {
+    const result = {};
+    if (visited.has(type) || currentDepth >= maxDepth) {
+        return result;
+    }
+    visited.add(type);
+    const properties = type.getProperties();
+    for (const prop of properties) {
+        const propName = prop.getName();
+        const propDecl = prop.valueDeclaration || prop.declarations?.[0];
+        if (!propDecl)
+            continue;
+        try {
+            const propType = checker.getTypeOfSymbolAtLocation(prop, propDecl);
+            const isOptional = !!(prop.flags & ts.SymbolFlags.Optional);
+            let typeString = checker.typeToString(propType, propDecl, ts.TypeFormatFlags.NoTruncation |
+                ts.TypeFormatFlags.UseFullyQualifiedType);
+            if (isOptional && !typeString.includes('undefined')) {
+                typeString = `${typeString} | undefined`;
+            }
+            result[propName] = typeString;
+        }
+        catch (err) {
+            result[propName] = 'any';
+        }
+    }
+    return result;
+}
+/**
+ * Extract metadata for a service from its TypeScript declaration
+ */
+export function extractServiceMetadata(serviceName, type, checker, rootDir) {
+    const property = type.getProperty(serviceName);
+    if (!property) {
+        return null;
+    }
+    const declaration = property.valueDeclaration || property.declarations?.[0];
+    if (!declaration) {
+        return null;
+    }
+    const sourceFile = declaration.getSourceFile();
+    const filePath = sourceFile.fileName;
+    const serviceType = checker.getTypeOfSymbolAtLocation(property, declaration);
+    let typeDeclaration = null;
+    if (serviceType.symbol) {
+        const typeDecl = serviceType.symbol.valueDeclaration ||
+            serviceType.symbol.declarations?.[0];
+        if (typeDecl &&
+            (ts.isInterfaceDeclaration(typeDecl) ||
+                ts.isClassDeclaration(typeDecl) ||
+                ts.isTypeAliasDeclaration(typeDecl))) {
+            typeDeclaration = typeDecl;
+        }
+    }
+    let summary = '';
+    let description = '';
+    if (typeDeclaration) {
+        const jsDoc = extractJSDoc(typeDeclaration);
+        summary = jsDoc.summary;
+        description = jsDoc.description;
+    }
+    else if (ts.isPropertySignature(declaration) ||
+        ts.isPropertyDeclaration(declaration)) {
+        const jsDoc = extractJSDoc(declaration);
+        summary = jsDoc.summary;
+        description = jsDoc.description;
+    }
+    let interfaceString = '';
+    if (typeDeclaration) {
+        interfaceString = serializeTypeToString(typeDeclaration, sourceFile, checker);
+    }
+    else {
+        interfaceString = checker.typeToString(serviceType, declaration, ts.TypeFormatFlags.NoTruncation);
+    }
+    const { packageName, version } = getPackageInfo(filePath);
+    const relativePath = path.relative(rootDir, filePath);
+    const expandedProperties = expandInterfaceProperties(serviceType, checker);
+    return {
+        name: serviceName,
+        summary,
+        description,
+        package: packageName,
+        path: relativePath,
+        version,
+        interface: interfaceString,
+        expandedProperties,
+    };
+}
+/**
+ * Extract metadata for all services in a type
+ */
+export function extractAllServiceMetadata(servicesType, checker, rootDir) {
+    const metadata = [];
+    const serviceNames = servicesType
+        .getProperties()
+        .map((prop) => prop.getName());
+    for (const serviceName of serviceNames) {
+        const serviceMeta = extractServiceMetadata(serviceName, servicesType, checker, rootDir);
+        if (serviceMeta) {
+            metadata.push(serviceMeta);
+        }
+    }
+    return metadata;
+}

package/dist/utils/get-files-and-methods.d.ts

@@ -7,15 +7,15 @@ interface Meta {
 }
 export type FilesAndMethods = {
     userSessionType: Meta;
-    sessionServicesType: Meta;
+    wireServicesType: Meta;
     singletonServicesType: Meta;
     pikkuConfigType: Meta;
     pikkuConfigFactory: Meta;
     singletonServicesFactory: Meta;
-    sessionServicesFactory: Meta;
+    wireServicesFactory: Meta;
 };
 export type FilesAndMethodsErrors = Map<string, PathToNameAndType>;
-export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, }?: InspectorOptions["types"]) => {
+export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, }?: InspectorOptions["types"]) => {
     result: Partial<FilesAndMethods>;
     errors: FilesAndMethodsErrors;
 };

package/dist/utils/get-files-and-methods.js

@@ -46,16 +46,16 @@ const getMetaTypes = (type, map, desiredType, errors) => {
     }
     return;
 };
-export const getFilesAndMethods = ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = {}) => {
+export const getFilesAndMethods = ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, } = {}) => {
     const errors = new Map();
     const result = {
         userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType, errors),
         singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap, undefined, errors),
-        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap, undefined, errors),
+        wireServicesType: getMetaTypes('CoreServices', wireServicesTypeImportMap, undefined, errors),
         pikkuConfigType: getMetaTypes('CoreConfig', configTypeImportMap, undefined, errors),
         pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType, errors),
         singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType, errors),
-        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType, errors),
+        wireServicesFactory: getMetaTypes('CreateWireServices', wireServicesFactories, wireServicesFactoryType, errors),
     };
     return { result, errors };
 };

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

@@ -1,12 +1,20 @@
-import { PikkuDocs } from '@pikku/core';
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
-export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | PikkuDocs | boolean;
+export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | boolean;
 /**
- * Gets the 'tags' property from an object and validates it's an array.
- * Logs a critical error if tags is not an array but still returns the value.
+ * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object
+ * @param obj - The TypeScript object literal expression to extract metadata from
+ * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
+ * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
  * @param logger - Optional logger instance; if not provided, uses console.error
+ * @returns Object containing the common wire metadata fields
  */
-export declare const getPropertyTags: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
+export declare const getCommonWireMetaData: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
     critical: (code: ErrorCode, message: string) => void;
-}) => string[] | undefined;
+}) => {
+    title?: string;
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    errors?: string[];
+};

package/dist/utils/get-property-value.js

@@ -19,35 +19,6 @@ export const getPropertyValue = (obj, propertyName) => {
                 .filter((item) => item !== null); // Filter non-null and assert type
             return stringArray.length > 0 ? stringArray : null;
         }
-        // Special handling for 'docs' -> expect RouteDocs
-        if (propertyName === 'docs' && ts.isObjectLiteralExpression(initializer)) {
-            const docs = {};
-            initializer.properties.forEach((prop) => {
-                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-                    const propName = prop.name.text;
-                    if (propName === 'summary' && ts.isStringLiteral(prop.initializer)) {
-                        docs.summary = prop.initializer.text;
-                    }
-                    else if (propName === 'description' &&
-                        ts.isStringLiteral(prop.initializer)) {
-                        docs.description = prop.initializer.text;
-                    }
-                    else if (propName === 'tags' &&
-                        ts.isArrayLiteralExpression(prop.initializer)) {
-                        docs.tags = prop.initializer.elements
-                            .filter(ts.isStringLiteral)
-                            .map((element) => element.text);
-                    }
-                    else if (propName === 'errors' &&
-                        ts.isArrayLiteralExpression(prop.initializer)) {
-                        docs.errors = prop.initializer.elements
-                            .filter(ts.isIdentifier)
-                            .map((element) => element.text);
-                    }
-                }
-            });
-            return docs;
-        }
         // booleans -> true/false
         if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
             return true;
@@ -66,21 +37,62 @@ export const getPropertyValue = (obj, propertyName) => {
     return null;
 };
 /**
- * Gets the 'tags' property from an object and validates it's an array.
- * Logs a critical error if tags is not an array but still returns the value.
+ * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object
+ * @param obj - The TypeScript object literal expression to extract metadata from
+ * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
+ * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
  * @param logger - Optional logger instance; if not provided, uses console.error
+ * @returns Object containing the common wire metadata fields
  */
-export const getPropertyTags = (obj, wiringType, wiringName, logger) => {
-    const tagsValue = getPropertyValue(obj, 'tags');
-    if (tagsValue !== null && !Array.isArray(tagsValue)) {
-        const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`;
-        if (logger) {
-            logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
-        }
-        else {
-            console.error(errorMsg);
+export const getCommonWireMetaData = (obj, wiringType, wiringName, logger) => {
+    const metadata = {};
+    obj.properties.forEach((prop) => {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            const propName = prop.name.text;
+            if (propName === 'title' && ts.isStringLiteral(prop.initializer)) {
+                metadata.title = prop.initializer.text;
+            }
+            else if (propName === 'summary' &&
+                ts.isStringLiteral(prop.initializer)) {
+                metadata.summary = prop.initializer.text;
+            }
+            else if (propName === 'description' &&
+                ts.isStringLiteral(prop.initializer)) {
+                metadata.description = prop.initializer.text;
+            }
+            else if (propName === 'tags') {
+                if (ts.isArrayLiteralExpression(prop.initializer)) {
+                    metadata.tags = prop.initializer.elements
+                        .filter(ts.isStringLiteral)
+                        .map((element) => element.text);
+                }
+                else {
+                    const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`;
+                    if (logger) {
+                        logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
+                    }
+                    else {
+                        console.error(errorMsg);
+                    }
+                }
+            }
+            else if (propName === 'errors') {
+                if (ts.isArrayLiteralExpression(prop.initializer)) {
+                    metadata.errors = prop.initializer.elements
+                        .filter(ts.isIdentifier)
+                        .map((element) => element.text);
+                }
+                else {
+                    const errorMsg = `${wiringType} '${wiringName}' has invalid 'errors' property - must be an array of error identifiers.`;
+                    if (logger) {
+                        logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
+                    }
+                    else {
+                        console.error(errorMsg);
+                    }
+                }
+            }
         }
-        // Return undefined but don't stop processing - error will be caught by the exit handler
-    }
-    return Array.isArray(tagsValue) ? tagsValue : undefined;
+    });
+    return metadata;
 };

package/dist/utils/post-process.d.ts

@@ -1,3 +1,4 @@
+import * as ts from 'typescript';
 import { InspectorState } from '../types.js';
 import { MiddlewareMetadata, PermissionMetadata } from '@pikku/core';
 /**
@@ -14,3 +15,11 @@ export declare function extractWireNames(list?: MiddlewareMetadata[] | Permissio
  * in the add-* methods during AST traversal for efficiency.
  */
 export declare function aggregateRequiredServices(state: InspectorState | Omit<InspectorState, 'typesLookup'>): void;
+/**
+ * Extract service interface metadata for all user-defined services.
+ * This extracts metadata for services in SingletonServices and Services types
+ * to generate documentation for AI consumption.
+ *
+ * Must be called after aggregateRequiredServices() to ensure types are loaded.
+ */
+export declare function extractServiceInterfaceMetadata(state: InspectorState | Omit<InspectorState, 'typesLookup'>, checker: ts.TypeChecker): void;

package/dist/utils/post-process.js

@@ -1,4 +1,5 @@
 import { extractTypeKeys } from './type-utils.js';
+import { extractAllServiceMetadata, } from './extract-service-metadata.js';
 /**
  * Helper to extract wire-level middleware/permission names from metadata.
  * Only extracts type:'wire' variants (individual middleware/permissions).
@@ -60,9 +61,9 @@ function extractAllServices(state) {
     const servicesTypes = state.typesLookup.get('Services');
     if (servicesTypes && servicesTypes.length > 0) {
         const allServiceNames = extractTypeKeys(servicesTypes[0]);
-        // Session services are those in Services but not in SingletonServices
+        // Wire services are those in Services but not in SingletonServices
         const singletonSet = new Set(state.serviceAggregation.allSingletonServices);
-        state.serviceAggregation.allSessionServices = allServiceNames
+        state.serviceAggregation.allWireServices = allServiceNames
             .filter((name) => !singletonSet.has(name))
             .sort();
     }
@@ -152,7 +153,7 @@ export function aggregateRequiredServices(state) {
         expandAndAddGroupServices(resourceMeta.permissions, state, addServices, false);
     }
     // 5. Services from session service factories
-    for (const singletonServices of state.sessionServicesMeta.values()) {
+    for (const singletonServices of state.wireServicesMeta.values()) {
         singletonServices.forEach((service) => {
             if (!internalServices.has(service)) {
                 requiredServices.add(service);
@@ -160,3 +161,29 @@ export function aggregateRequiredServices(state) {
         });
     }
 }
+/**
+ * Extract service interface metadata for all user-defined services.
+ * This extracts metadata for services in SingletonServices and Services types
+ * to generate documentation for AI consumption.
+ *
+ * Must be called after aggregateRequiredServices() to ensure types are loaded.
+ */
+export function extractServiceInterfaceMetadata(state, checker) {
+    if (!('typesLookup' in state)) {
+        return;
+    }
+    const allMetadata = [];
+    const singletonServicesTypes = state.typesLookup.get('SingletonServices');
+    if (singletonServicesTypes && singletonServicesTypes.length > 0) {
+        const singletonMeta = extractAllServiceMetadata(singletonServicesTypes[0], checker, state.rootDir);
+        allMetadata.push(...singletonMeta);
+    }
+    const servicesTypes = state.typesLookup.get('Services');
+    if (servicesTypes && servicesTypes.length > 0) {
+        const wireServicesMeta = extractAllServiceMetadata(servicesTypes[0], checker, state.rootDir);
+        const singletonNames = new Set(state.serviceAggregation.allSingletonServices);
+        const uniqueWireServices = wireServicesMeta.filter((meta) => !singletonNames.has(meta.name));
+        allMetadata.push(...uniqueWireServices);
+    }
+    state.serviceMetadata = allMetadata;
+}