@pikku/inspector 0.10.2 → 0.11.1

package/dist/utils/type-utils.js

@@ -2,6 +2,61 @@ import * as ts from 'typescript';
 export const extractTypeKeys = (type) => {
     return type.getProperties().map((symbol) => symbol.getName());
 };
+/**
+ * Resolve an identifier or call expression to the actual function declaration
+ */
+export function resolveFunctionDeclaration(node, checker) {
+    // If it's already a function-like node, return it
+    if (ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node)) {
+        return node;
+    }
+    // If it's a call expression (e.g., pikkuWorkflowFunc(...)), get its first argument
+    if (ts.isCallExpression(node) && node.arguments.length > 0) {
+        const firstArg = node.arguments[0];
+        if (ts.isFunctionExpression(firstArg) || ts.isArrowFunction(firstArg)) {
+            return firstArg;
+        }
+    }
+    // If it's an identifier, resolve to declaration
+    if (ts.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (!symbol)
+            return null;
+        // Try valueDeclaration first, then fallback to declarations[0]
+        const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+        if (!decl)
+            return null;
+        // If it's an import specifier, resolve the aliased symbol
+        if (ts.isImportSpecifier(decl)) {
+            const aliasedSymbol = checker.getAliasedSymbol(symbol);
+            if (aliasedSymbol) {
+                const aliasedDecl = aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0];
+                if (aliasedDecl) {
+                    // For variable declarations, get the initializer
+                    if (ts.isVariableDeclaration(aliasedDecl) &&
+                        aliasedDecl.initializer) {
+                        return resolveFunctionDeclaration(aliasedDecl.initializer, checker);
+                    }
+                    // For function declarations, return directly
+                    if (ts.isFunctionDeclaration(aliasedDecl)) {
+                        return aliasedDecl;
+                    }
+                }
+            }
+        }
+        // If it's a variable declaration, get the initializer
+        if (ts.isVariableDeclaration(decl) && decl.initializer) {
+            return resolveFunctionDeclaration(decl.initializer, checker);
+        }
+        // If it's a function declaration
+        if (ts.isFunctionDeclaration(decl)) {
+            return decl;
+        }
+    }
+    return null;
+}
 export function getPropertyAssignmentInitializer(obj, propName, followShorthand = false, checker) {
     for (const prop of obj.properties) {
         // ①  foo: () => {}

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

@@ -0,0 +1,13 @@
+import { ServiceMetadata } from './extract-service-metadata.js';
+/**
+ * Write service metadata to a JSON file in .pikku/services directory
+ */
+export declare function writeServiceMetadata(serviceMeta: ServiceMetadata, outDir: string): void;
+/**
+ * Write all service metadata files
+ */
+export declare function writeAllServiceMetadata(servicesMetadata: ServiceMetadata[], outDir: string): void;
+/**
+ * Clean up services directory (remove old service JSON files)
+ */
+export declare function cleanServicesDirectory(outDir: string): void;

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

@@ -0,0 +1,37 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Write service metadata to a JSON file in .pikku/services directory
+ */
+export function writeServiceMetadata(serviceMeta, outDir) {
+    const servicesDir = path.join(outDir, 'services');
+    if (!fs.existsSync(servicesDir)) {
+        fs.mkdirSync(servicesDir, { recursive: true });
+    }
+    const fileName = `${serviceMeta.name}.gen.json`;
+    const filePath = path.join(servicesDir, fileName);
+    const jsonContent = JSON.stringify(serviceMeta, null, 2);
+    fs.writeFileSync(filePath, jsonContent, 'utf-8');
+}
+/**
+ * Write all service metadata files
+ */
+export function writeAllServiceMetadata(servicesMetadata, outDir) {
+    for (const serviceMeta of servicesMetadata) {
+        writeServiceMetadata(serviceMeta, outDir);
+    }
+}
+/**
+ * Clean up services directory (remove old service JSON files)
+ */
+export function cleanServicesDirectory(outDir) {
+    const servicesDir = path.join(outDir, 'services');
+    if (fs.existsSync(servicesDir)) {
+        const files = fs.readdirSync(servicesDir);
+        for (const file of files) {
+            if (file.endsWith('.gen.json')) {
+                fs.unlinkSync(path.join(servicesDir, file));
+            }
+        }
+    }
+}

package/dist/visit.js

@@ -4,6 +4,7 @@ import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
 import { addHTTPRoute } from './add/add-http-route.js';
 import { addSchedule } from './add/add-schedule.js';
 import { addQueueWorker } from './add/add-queue-worker.js';
+import { addWorkflow } from './add/add-workflow.js';
 import { addMCPResource } from './add/add-mcp-resource.js';
 import { addMCPTool } from './add/add-mcp-tool.js';
 import { addMCPPrompt } from './add/add-mcp-prompt.js';
@@ -15,15 +16,16 @@ import { addPermission } from './add/add-permission.js';
 import { addCLI, addCLIRenderers } from './add/add-cli.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
-    addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices', state);
+    addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
     addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession', state);
     addFileExtendsCoreType(node, checker, state.configTypeImportMap, 'CoreConfig', state);
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
-    addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices', state);
+    addFileWithFactory(node, checker, state.wireServicesFactories, 'CreateWireServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addRPCInvocations(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
+    addWorkflow(logger, node, checker, state, options);
     ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));
 };
 export const visitRoutes = (logger, checker, node, state, options) => {

package/dist/workflow/extract-simple-workflow.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+import { WorkflowStepMeta } from '@pikku/core/workflow';
+/**
+ * Result of simple workflow extraction
+ */
+export interface ExtractionResult {
+    status: 'ok' | 'error';
+    steps?: WorkflowStepMeta[];
+    reason?: string;
+    simple?: boolean;
+}
+/**
+ * Extract simple workflow metadata from a function declaration
+ */
+export declare function extractSimpleWorkflow(funcNode: ts.Node, checker: ts.TypeChecker): ExtractionResult;