@constructive-io/graphql-codegen 4.7.3 → 4.8.1

package/core/codegen/hooks-docs-generator.js

@@ -4,6 +4,7 @@ exports.generateHooksReadme = generateHooksReadme;
 exports.generateHooksAgentsDocs = generateHooksAgentsDocs;
 exports.getHooksMcpTools = getHooksMcpTools;
 exports.generateHooksSkills = generateHooksSkills;
+const komoji_1 = require("komoji");
 const docs_utils_1 = require("./docs-utils");
 const utils_1 = require("./utils");
 function getCustomHookName(op) {
@@ -377,8 +378,11 @@ function getHooksMcpTools(tables, customOperations) {
     }
     return tools;
 }
-function generateHooksSkills(tables, customOperations) {
+function generateHooksSkills(tables, customOperations, targetName) {
     const files = [];
+    const skillName = `hooks-${targetName}`;
+    const referenceNames = [];
+    // Generate reference files for each table
     for (const table of tables) {
         const { singularName, pluralName } = (0, utils_1.getTableNames)(table);
         const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
@@ -386,10 +390,12 @@ function generateHooksSkills(tables, customOperations) {
         const selectFields = scalarFields
             .map((f) => `${f.name}: true`)
             .join(', ');
+        const refName = (0, komoji_1.toKebabCase)(singularName);
+        referenceNames.push(refName);
         files.push({
-            fileName: `skills/${(0, utils_1.lcFirst)(singularName)}.md`,
-            content: (0, docs_utils_1.buildSkillFile)({
-                name: `hooks-${(0, utils_1.lcFirst)(singularName)}`,
+            fileName: `${skillName}/references/${refName}.md`,
+            content: (0, docs_utils_1.buildSkillReference)({
+                title: singularName,
                 description: table.description || `React Query hooks for ${table.name} data operations`,
                 language: 'typescript',
                 usage: [
@@ -429,15 +435,18 @@ function generateHooksSkills(tables, customOperations) {
             }),
         });
     }
+    // Generate reference files for custom operations
     for (const op of customOperations) {
         const hookName = getCustomHookName(op);
         const callArgs = op.args.length > 0
             ? `{ ${op.args.map((a) => `${a.name}: '<value>'`).join(', ')} }`
             : '';
+        const refName = (0, komoji_1.toKebabCase)(op.name);
+        referenceNames.push(refName);
         files.push({
-            fileName: `skills/${op.name}.md`,
-            content: (0, docs_utils_1.buildSkillFile)({
-                name: `hooks-${op.name}`,
+            fileName: `${skillName}/references/${refName}.md`,
+            content: (0, docs_utils_1.buildSkillReference)({
+                title: op.name,
                 description: op.description ||
                     `React Query ${op.kind} hook for ${op.name}`,
                 language: 'typescript',
@@ -464,5 +473,36 @@ function generateHooksSkills(tables, customOperations) {
             }),
         });
     }
+    // Generate the overview SKILL.md
+    const hookExamples = tables.slice(0, 3).map((t) => (0, utils_1.getListQueryHookName)(t));
+    files.push({
+        fileName: `${skillName}/SKILL.md`,
+        content: (0, docs_utils_1.buildSkillFile)({
+            name: skillName,
+            description: `React Query hooks for the ${targetName} API — provides typed query and mutation hooks for ${tables.length} tables and ${customOperations.length} custom operations`,
+            language: 'typescript',
+            usage: [
+                `// Import hooks`,
+                `import { ${hookExamples[0] || 'useModelQuery'} } from './hooks';`,
+                '',
+                `// Query hooks: use<Model>Query, use<Model>sQuery`,
+                `// Mutation hooks: useCreate<Model>Mutation, useUpdate<Model>Mutation, useDelete<Model>Mutation`,
+                '',
+                `const { data, isLoading } = ${hookExamples[0] || 'useModelQuery'}({`,
+                `  selection: { fields: { id: true } },`,
+                `});`,
+            ],
+            examples: [
+                {
+                    description: 'Query records',
+                    code: [
+                        `const { data, isLoading } = ${hookExamples[0] || 'useModelQuery'}({`,
+                        '  selection: { fields: { id: true } },',
+                        '});',
+                    ],
+                },
+            ],
+        }, referenceNames),
+    });
     return files;
 }

package/core/codegen/orm/docs-generator.d.ts

@@ -3,4 +3,4 @@ import type { GeneratedDocFile, McpTool } from '../docs-utils';
 export declare function generateOrmReadme(tables: CleanTable[], customOperations: CleanOperation[]): GeneratedDocFile;
 export declare function generateOrmAgentsDocs(tables: CleanTable[], customOperations: CleanOperation[]): GeneratedDocFile;
 export declare function getOrmMcpTools(tables: CleanTable[], customOperations: CleanOperation[]): McpTool[];
-export declare function generateOrmSkills(tables: CleanTable[], customOperations: CleanOperation[]): GeneratedDocFile[];
+export declare function generateOrmSkills(tables: CleanTable[], customOperations: CleanOperation[], targetName: string): GeneratedDocFile[];

package/core/codegen/orm/docs-generator.js

@@ -4,6 +4,7 @@ exports.generateOrmReadme = generateOrmReadme;
 exports.generateOrmAgentsDocs = generateOrmAgentsDocs;
 exports.getOrmMcpTools = getOrmMcpTools;
 exports.generateOrmSkills = generateOrmSkills;
+const komoji_1 = require("komoji");
 const docs_utils_1 = require("../docs-utils");
 const utils_1 = require("../utils");
 function generateOrmReadme(tables, customOperations) {
@@ -346,30 +347,36 @@ function getOrmMcpTools(tables, customOperations) {
     }
     return tools;
 }
-function generateOrmSkills(tables, customOperations) {
+function generateOrmSkills(tables, customOperations, targetName) {
     const files = [];
+    const skillName = `orm-${targetName}`;
+    const referenceNames = [];
+    // Generate reference files for each table
     for (const table of tables) {
         const { singularName } = (0, utils_1.getTableNames)(table);
         const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
         const editableFields = (0, docs_utils_1.getEditableFields)(table);
+        const modelName = (0, utils_1.lcFirst)(singularName);
+        const refName = (0, komoji_1.toKebabCase)(singularName);
+        referenceNames.push(refName);
         files.push({
-            fileName: `skills/${(0, utils_1.lcFirst)(singularName)}.md`,
-            content: (0, docs_utils_1.buildSkillFile)({
-                name: `orm-${(0, utils_1.lcFirst)(singularName)}`,
+            fileName: `${skillName}/references/${refName}.md`,
+            content: (0, docs_utils_1.buildSkillReference)({
+                title: singularName,
                 description: table.description || `ORM operations for ${table.name} records`,
                 language: 'typescript',
                 usage: [
-                    `db.${(0, utils_1.lcFirst)(singularName)}.findMany({ select: { id: true } }).execute()`,
-                    `db.${(0, utils_1.lcFirst)(singularName)}.findOne({ ${pk.name}: '<value>', select: { id: true } }).execute()`,
-                    `db.${(0, utils_1.lcFirst)(singularName)}.create({ data: { ${editableFields.map((f) => `${f.name}: '<value>'`).join(', ')} }, select: { id: true } }).execute()`,
-                    `db.${(0, utils_1.lcFirst)(singularName)}.update({ where: { ${pk.name}: '<value>' }, data: { ${editableFields[0]?.name || 'field'}: '<new>' }, select: { id: true } }).execute()`,
-                    `db.${(0, utils_1.lcFirst)(singularName)}.delete({ where: { ${pk.name}: '<value>' } }).execute()`,
+                    `db.${modelName}.findMany({ select: { id: true } }).execute()`,
+                    `db.${modelName}.findOne({ ${pk.name}: '<value>', select: { id: true } }).execute()`,
+                    `db.${modelName}.create({ data: { ${editableFields.map((f) => `${f.name}: '<value>'`).join(', ')} }, select: { id: true } }).execute()`,
+                    `db.${modelName}.update({ where: { ${pk.name}: '<value>' }, data: { ${editableFields[0]?.name || 'field'}: '<new>' }, select: { id: true } }).execute()`,
+                    `db.${modelName}.delete({ where: { ${pk.name}: '<value>' } }).execute()`,
                 ],
                 examples: [
                     {
                         description: `List all ${singularName} records`,
                         code: [
-                            `const items = await db.${(0, utils_1.lcFirst)(singularName)}.findMany({`,
+                            `const items = await db.${modelName}.findMany({`,
                             `  select: { ${pk.name}: true, ${editableFields[0]?.name || 'name'}: true }`,
                             '}).execute();',
                         ],
@@ -377,7 +384,7 @@ function generateOrmSkills(tables, customOperations) {
                     {
                         description: `Create a ${singularName}`,
                         code: [
-                            `const item = await db.${(0, utils_1.lcFirst)(singularName)}.create({`,
+                            `const item = await db.${modelName}.create({`,
                             `  data: { ${editableFields.map((f) => `${f.name}: 'value'`).join(', ')} },`,
                             `  select: { ${pk.name}: true }`,
                             '}).execute();',
@@ -387,30 +394,60 @@ function generateOrmSkills(tables, customOperations) {
             }),
         });
     }
+    // Generate reference files for custom operations
     for (const op of customOperations) {
         const accessor = op.kind === 'query' ? 'query' : 'mutation';
         const callArgs = op.args.length > 0
             ? `{ ${op.args.map((a) => `${a.name}: '<value>'`).join(', ')} }`
             : '';
+        const refName = (0, komoji_1.toKebabCase)(op.name);
+        referenceNames.push(refName);
         files.push({
-            fileName: `skills/${op.name}.md`,
-            content: (0, docs_utils_1.buildSkillFile)({
-                name: `orm-${op.name}`,
+            fileName: `${skillName}/references/${refName}.md`,
+            content: (0, docs_utils_1.buildSkillReference)({
+                title: op.name,
                 description: op.description || `Execute the ${op.name} ${op.kind}`,
                 language: 'typescript',
-                usage: [
-                    `db.${accessor}.${op.name}(${callArgs}).execute()`,
-                ],
+                usage: [`db.${accessor}.${op.name}(${callArgs}).execute()`],
                 examples: [
                     {
                         description: `Run ${op.name}`,
-                        code: [
-                            `const result = await db.${accessor}.${op.name}(${callArgs}).execute();`,
-                        ],
+                        code: [`const result = await db.${accessor}.${op.name}(${callArgs}).execute();`],
                     },
                 ],
             }),
         });
     }
+    // Generate the overview SKILL.md
+    const tableNames = tables.map((t) => (0, utils_1.lcFirst)((0, utils_1.getTableNames)(t).singularName));
+    files.push({
+        fileName: `${skillName}/SKILL.md`,
+        content: (0, docs_utils_1.buildSkillFile)({
+            name: skillName,
+            description: `ORM client for the ${targetName} API — provides typed CRUD operations for ${tables.length} tables and ${customOperations.length} custom operations`,
+            language: 'typescript',
+            usage: [
+                `// Import the ORM client`,
+                `import { db } from './orm';`,
+                '',
+                `// Available models: ${tableNames.slice(0, 8).join(', ')}${tableNames.length > 8 ? ', ...' : ''}`,
+                `db.<model>.findMany({ select: { id: true } }).execute()`,
+                `db.<model>.findOne({ id: '<value>', select: { id: true } }).execute()`,
+                `db.<model>.create({ data: { ... }, select: { id: true } }).execute()`,
+                `db.<model>.update({ where: { id: '<value>' }, data: { ... }, select: { id: true } }).execute()`,
+                `db.<model>.delete({ where: { id: '<value>' } }).execute()`,
+            ],
+            examples: [
+                {
+                    description: 'Query records',
+                    code: [
+                        `const items = await db.${tableNames[0] || 'model'}.findMany({`,
+                        '  select: { id: true }',
+                        '}).execute();',
+                    ],
+                },
+            ],
+        }, referenceNames),
+    });
     return files;
 }

package/core/generate.d.ts

@@ -33,6 +33,11 @@ export interface GenerateResult {
  */
 export interface GenerateInternalOptions {
     skipCli?: boolean;
+    /**
+     * Internal-only name for the target when generating skills.
+     * Used by generateMulti() so skill names are stable and composable.
+     */
+    targetName?: string;
 }
 export declare function generate(options?: GenerateOptions, internalOptions?: GenerateInternalOptions): Promise<GenerateResult>;
 export declare function expandApiNamesToMultiTarget(config: GraphQLSDKConfigTarget): Record<string, GraphQLSDKConfigTarget> | null;

package/core/generate.js

@@ -66,6 +66,18 @@ const target_docs_generator_1 = require("./codegen/target-docs-generator");
 const introspect_1 = require("./introspect");
 const output_1 = require("./output");
 const pipeline_1 = require("./pipeline");
+const workspace_1 = require("./workspace");
+function resolveSkillsOutputDir(config, outputRoot) {
+    const workspaceRoot = (0, workspace_1.findWorkspaceRoot)(node_path_1.default.resolve(outputRoot)) ??
+        (0, workspace_1.findWorkspaceRoot)(process.cwd()) ??
+        process.cwd();
+    if (config.skillsPath) {
+        return node_path_1.default.isAbsolute(config.skillsPath)
+            ? config.skillsPath
+            : node_path_1.default.resolve(workspaceRoot, config.skillsPath);
+    }
+    return node_path_1.default.resolve(workspaceRoot, 'skills');
+}
 async function generate(options = {}, internalOptions) {
     // Apply defaults to get resolved config
     const config = (0, config_1.getConfigOptions)(options);
@@ -261,6 +273,8 @@ async function generate(options = {}, internalOptions) {
         ...(customOperations.mutations ?? []),
     ];
     const allMcpTools = [];
+    const targetName = internalOptions?.targetName ?? 'default';
+    const skillsToWrite = [];
     if (runOrm) {
         if (docsConfig.readme) {
             const readme = (0, docs_generator_2.generateOrmReadme)(tables, allCustomOps);
@@ -274,8 +288,8 @@ async function generate(options = {}, internalOptions) {
             allMcpTools.push(...(0, docs_generator_2.getOrmMcpTools)(tables, allCustomOps));
         }
         if (docsConfig.skills) {
-            for (const skill of (0, docs_generator_2.generateOrmSkills)(tables, allCustomOps)) {
-                filesToWrite.push({ path: node_path_1.default.posix.join('orm', skill.fileName), content: skill.content });
+            for (const skill of (0, docs_generator_2.generateOrmSkills)(tables, allCustomOps, targetName)) {
+                skillsToWrite.push({ path: skill.fileName, content: skill.content });
             }
         }
     }
@@ -292,8 +306,8 @@ async function generate(options = {}, internalOptions) {
             allMcpTools.push(...(0, hooks_docs_generator_1.getHooksMcpTools)(tables, allCustomOps));
         }
         if (docsConfig.skills) {
-            for (const skill of (0, hooks_docs_generator_1.generateHooksSkills)(tables, allCustomOps)) {
-                filesToWrite.push({ path: node_path_1.default.posix.join('hooks', skill.fileName), content: skill.content });
+            for (const skill of (0, hooks_docs_generator_1.generateHooksSkills)(tables, allCustomOps, targetName)) {
+                skillsToWrite.push({ path: skill.fileName, content: skill.content });
             }
         }
     }
@@ -313,8 +327,8 @@ async function generate(options = {}, internalOptions) {
             allMcpTools.push(...(0, docs_generator_1.getCliMcpTools)(tables, allCustomOps, toolName));
         }
         if (docsConfig.skills) {
-            for (const skill of (0, docs_generator_1.generateSkills)(tables, allCustomOps, toolName)) {
-                filesToWrite.push({ path: node_path_1.default.posix.join('cli', skill.fileName), content: skill.content });
+            for (const skill of (0, docs_generator_1.generateSkills)(tables, allCustomOps, toolName, targetName)) {
+                skillsToWrite.push({ path: skill.fileName, content: skill.content });
             }
         }
     }
@@ -352,6 +366,21 @@ async function generate(options = {}, internalOptions) {
             };
         }
         allFilesWritten.push(...(writeResult.filesWritten ?? []));
+        if (skillsToWrite.length > 0) {
+            const skillsOutputDir = resolveSkillsOutputDir(config, outputRoot);
+            const skillsWriteResult = await (0, output_1.writeGeneratedFiles)(skillsToWrite, skillsOutputDir, [], {
+                pruneStaleFiles: false,
+            });
+            if (!skillsWriteResult.success) {
+                return {
+                    success: false,
+                    message: `Failed to write generated skill files: ${skillsWriteResult.errors?.join(', ')}`,
+                    output: skillsOutputDir,
+                    errors: skillsWriteResult.errors,
+                };
+            }
+            allFilesWritten.push(...(skillsWriteResult.filesWritten ?? []));
+        }
     }
     const generators = [
         runReactQuery && 'React Query',
@@ -530,7 +559,7 @@ async function generateMulti(options) {
                 dryRun,
                 schemaOnly,
                 schemaOnlyFilename: schemaOnly ? `${name}.graphql` : undefined,
-            }, useUnifiedCli ? { skipCli: true } : undefined);
+            }, useUnifiedCli ? { skipCli: true, targetName: name } : { targetName: name });
             results.push({ name, result });
             if (!result.success) {
                 hasError = true;
@@ -613,17 +642,24 @@ async function generateMulti(options) {
             if (docsConfig.mcp) {
                 allMcpTools.push(...(0, docs_generator_1.getMultiTargetCliMcpTools)(docsInput));
             }
-            if (docsConfig.skills) {
-                for (const skill of (0, docs_generator_1.generateMultiTargetSkills)(docsInput)) {
-                    cliFilesToWrite.push({ path: node_path_1.default.posix.join('cli', skill.fileName), content: skill.content });
-                }
-            }
             if (docsConfig.mcp && allMcpTools.length > 0) {
                 const mcpFile = (0, target_docs_generator_1.generateCombinedMcpConfig)(allMcpTools, toolName);
                 cliFilesToWrite.push({ path: node_path_1.default.posix.join('cli', mcpFile.fileName), content: mcpFile.content });
             }
             const { writeGeneratedFiles: writeFiles } = await Promise.resolve().then(() => __importStar(require('./output')));
             await writeFiles(cliFilesToWrite, '.', [], { pruneStaleFiles: false });
+            if (docsConfig.skills) {
+                const cliSkillsToWrite = (0, docs_generator_1.generateMultiTargetSkills)(docsInput).map((skill) => ({
+                    path: skill.fileName,
+                    content: skill.content,
+                }));
+                const firstTargetResolved = (0, config_1.getConfigOptions)({
+                    ...(firstTargetConfig ?? {}),
+                    ...(cliOverrides ?? {}),
+                });
+                const skillsOutputDir = resolveSkillsOutputDir(firstTargetResolved, firstTargetResolved.output);
+                await writeFiles(cliSkillsToWrite, skillsOutputDir, [], { pruneStaleFiles: false });
+            }
         }
         // Generate root-root README if multi-target
         if (names.length > 1 && targetInfos.length > 0 && !dryRun) {

package/core/workspace.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Find the workspace root directory.
+ *
+ * Search order:
+ * 1. pnpm-workspace.yaml (pnpm workspaces)
+ * 2. lerna.json (lerna workspaces)
+ * 3. package.json with "workspaces" field (npm/yarn workspaces)
+ * 4. Nearest package.json (fallback for non-workspace projects)
+ *
+ * @param cwd - Starting directory to search from (defaults to process.cwd())
+ * @returns The workspace root path, or null if nothing found
+ */
+export declare function findWorkspaceRoot(cwd?: string): string | null;

package/core/workspace.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspaceRoot = findWorkspaceRoot;
+/**
+ * Workspace detection utilities
+ *
+ * Finds the root of a workspace by walking up directories looking for
+ * workspace markers (pnpm-workspace.yaml, lerna.json, package.json with workspaces).
+ * Falls back to the nearest package.json directory.
+ *
+ * Inspired by @pgpmjs/env walkUp / resolvePnpmWorkspace patterns.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Walk up directories from startDir looking for a file.
+ * Returns the directory containing the file, or null if not found.
+ */
+function walkUp(startDir, filename) {
+    let currentDir = (0, node_path_1.resolve)(startDir);
+    while (currentDir) {
+        const targetPath = (0, node_path_1.resolve)(currentDir, filename);
+        if ((0, node_fs_1.existsSync)(targetPath)) {
+            return currentDir;
+        }
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    return null;
+}
+/**
+ * Find the first pnpm workspace root by looking for pnpm-workspace.yaml
+ */
+function findPnpmWorkspace(cwd) {
+    return walkUp(cwd, 'pnpm-workspace.yaml');
+}
+/**
+ * Find the first lerna workspace root by looking for lerna.json
+ */
+function findLernaWorkspace(cwd) {
+    return walkUp(cwd, 'lerna.json');
+}
+/**
+ * Find the first npm/yarn workspace root by looking for package.json with workspaces field
+ */
+function findNpmWorkspace(cwd) {
+    let currentDir = (0, node_path_1.resolve)(cwd);
+    const root = (0, node_path_1.parse)(currentDir).root;
+    while (currentDir !== root) {
+        const packageJsonPath = (0, node_path_1.resolve)(currentDir, 'package.json');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf8'));
+                if (packageJson.workspaces) {
+                    return currentDir;
+                }
+            }
+            catch {
+                // Ignore JSON parse errors
+            }
+        }
+        currentDir = (0, node_path_1.dirname)(currentDir);
+    }
+    return null;
+}
+/**
+ * Find the nearest package.json directory (fallback)
+ */
+function findPackageRoot(cwd) {
+    return walkUp(cwd, 'package.json');
+}
+/**
+ * Find the workspace root directory.
+ *
+ * Search order:
+ * 1. pnpm-workspace.yaml (pnpm workspaces)
+ * 2. lerna.json (lerna workspaces)
+ * 3. package.json with "workspaces" field (npm/yarn workspaces)
+ * 4. Nearest package.json (fallback for non-workspace projects)
+ *
+ * @param cwd - Starting directory to search from (defaults to process.cwd())
+ * @returns The workspace root path, or null if nothing found
+ */
+function findWorkspaceRoot(cwd = process.cwd()) {
+    return (findPnpmWorkspace(cwd) ??
+        findLernaWorkspace(cwd) ??
+        findNpmWorkspace(cwd) ??
+        findPackageRoot(cwd));
+}

package/esm/core/codegen/cli/command-map-generator.js

@@ -11,6 +11,25 @@ function createNamedImportDeclaration(moduleSpecifier, namedImports, typeOnly =
     decl.importKind = typeOnly ? 'type' : 'value';
     return decl;
 }
+/**
+ * Build the command handler function type:
+ * (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, options: CLIOptions) => Promise<void>
+ * This matches the actual exported handler signatures from table/custom command files.
+ */
+function buildCommandHandlerType() {
+    const argvParam = t.identifier('argv');
+    argvParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Partial'), t.tsTypeParameterInstantiation([
+        t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+            t.tsStringKeyword(),
+            t.tsUnknownKeyword(),
+        ])),
+    ])));
+    const prompterParam = t.identifier('prompter');
+    prompterParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Inquirerer')));
+    const optionsParam = t.identifier('options');
+    optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CLIOptions')));
+    return t.tsFunctionType(null, [argvParam, prompterParam, optionsParam], t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tsVoidKeyword()]))));
+}
 export function generateCommandMap(tables, customOperations, toolName) {
     const statements = [];
     statements.push(createNamedImportDeclaration('inquirerer', [
@@ -37,18 +56,17 @@ export function generateCommandMap(tables, customOperations, toolName) {
         statements.push(createImportDeclaration(`./commands/${kebab}`, importName));
     }
     const mapProperties = commandEntries.map((entry) => t.objectProperty(t.stringLiteral(entry.kebab), t.identifier(entry.importName)));
-    const createCommandMapFunc = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('createCommandMap'), t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
-    ]);
-    const createCommandMapAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
-        t.tsStringKeyword(),
-        t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsAnyKeyword())),
-    ])));
+    // Build command handler type matching actual handler signature:
+    // (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, options: CLIOptions) => Promise<void>
+    const commandHandlerType = buildCommandHandlerType();
     const createCommandMapId = t.identifier('createCommandMap');
     createCommandMapId.typeAnnotation = t.tsTypeAnnotation(t.tsParenthesizedType(t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
         t.tsStringKeyword(),
-        t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsUnknownKeyword())),
+        commandHandlerType,
     ]))))));
+    const createCommandMapFunc = t.variableDeclaration('const', [
+        t.variableDeclarator(createCommandMapId, t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
+    ]);
     statements.push(createCommandMapFunc);
     const usageLines = [
         '',
@@ -115,7 +133,7 @@ export function generateCommandMap(tables, customOperations, toolName) {
                     ]),
                 ]))),
             ]),
-            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.memberExpression(t.identifier('answer'), t.identifier('command')))),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.tsAsExpression(t.memberExpression(t.identifier('answer'), t.identifier('command')), t.tsStringKeyword()))),
         ])),
         t.variableDeclaration('const', [
             t.variableDeclarator(t.identifier('commandFn'), t.memberExpression(t.identifier('commandMap'), t.identifier('command'), true)),
@@ -186,8 +204,15 @@ export function generateMultiTargetCommandMap(input) {
         }
     }
     const mapProperties = commandEntries.map((entry) => t.objectProperty(t.stringLiteral(entry.kebab), t.identifier(entry.importName)));
+    // Build command handler type matching actual handler signature
+    const multiTargetCommandHandlerType = buildCommandHandlerType();
+    const multiTargetCreateCommandMapId = t.identifier('createCommandMap');
+    multiTargetCreateCommandMapId.typeAnnotation = t.tsTypeAnnotation(t.tsParenthesizedType(t.tsFunctionType(null, [], t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([
+        t.tsStringKeyword(),
+        multiTargetCommandHandlerType,
+    ]))))));
     const createCommandMapFunc = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('createCommandMap'), t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
+        t.variableDeclarator(multiTargetCreateCommandMapId, t.arrowFunctionExpression([], t.objectExpression(mapProperties))),
     ]);
     statements.push(createCommandMapFunc);
     const usageLines = [
@@ -261,7 +286,7 @@ export function generateMultiTargetCommandMap(input) {
                     ]),
                 ]))),
             ]),
-            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.memberExpression(t.identifier('answer'), t.identifier('command')))),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier('command'), t.tsAsExpression(t.memberExpression(t.identifier('answer'), t.identifier('command')), t.tsStringKeyword()))),
         ])),
         t.variableDeclaration('const', [
             t.variableDeclarator(t.identifier('commandFn'), t.memberExpression(t.identifier('commandMap'), t.identifier('command'), true)),