@wato787/microcms-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wato787
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# microCMS CLI
+
+microCMS 用の CLI ツールです。実行コマンドは `microcms-cli` です。  
+npm 配布物は事前ビルド済みのため、実行時に Bun は不要です（Node.js 18+）。
+
+- `gen-types`: Management API のスキーマから TypeScript 型を生成
+
+## Install
+
+```bash
+npm install -g @wato787/microcms-cli
+# または
+bun add -g @wato787/microcms-cli
+```
+
+```bash
+# インストールせずに実行
+npx @wato787/microcms-cli gen-types blog
+```
+
+## Commands
+
+### `gen-types [endpointId] [options]`
+
+microCMS Management API（`/api/v1/apis`）から API スキーマを取得し、TypeScript 型を生成します。
+生成結果は `microcms.d.ts` に集約されます。
+共通型（`MicroCMSListResponse` など）は `microcms-js-sdk` の公式定義に合わせています。
+このコマンドは Content API のコンテンツ取得エンドポイントは呼びません。
+
+- `endpointId` 指定時: 対象 endpoint のスキーマのみ取得
+- `--all` 指定時: API 一覧を取得して全 endpoint を生成
+- 生成型: `XxxSchema`（スキーマ本体）と `XxxContent`（SDK の共通メタ情報付き）
+- 利用する Management API: `/api/v1/apis`, `/api/v1/apis/{endpoint}`
+
+```bash
+# 単一エンドポイント
+microcms-cli gen-types blog
+
+# 出力先ディレクトリ指定（デフォルトは ./types/microcms.d.ts）
+microcms-cli gen-types blog -o ./src/types/microcms
+# => ./src/types/microcms/microcms.d.ts
+
+# 出力ファイルを直接指定
+microcms-cli gen-types blog -o ./src/types/microcms.d.ts
+
+# 全エンドポイントを一括生成
+microcms-cli gen-types --all
+# endpointIdを渡しても --all 指定時は無視されます
+microcms-cli gen-types blog --all
+
+# CIなどで環境変数をインライン指定
+MICROCMS_SERVICE_DOMAIN=your-service-id \
+MICROCMS_MANAGEMENT_API_KEY=your-management-api-key \
+microcms-cli gen-types blog
+```
+
+#### Options
+
+- `-o, --output <path>`: 出力先（ディレクトリ指定時は `<path>/microcms.d.ts`、デフォルト `./types/microcms.d.ts`）
+- `--all`: 全エンドポイントの型を生成
+- `--service-domain <domain>`: `MICROCMS_SERVICE_DOMAIN` をCLI引数で上書き
+- `--api-key <key>`: `MICROCMS_MANAGEMENT_API_KEY` をCLI引数で上書き
+
+#### Required environment variables
+
+`gen-types` は **実行した利用者の環境変数** から設定を読み取ります。  
+CLI引数で指定しない場合、以下の環境変数が必要です。
+
+```bash
+MICROCMS_SERVICE_DOMAIN=your-service-id
+MICROCMS_MANAGEMENT_API_KEY=your-management-api-key
+```
+
+#### Required Management API permission
+
+`MICROCMS_MANAGEMENT_API_KEY` には、マネジメントAPIのGET権限として **「API情報の取得」** が必要です。
+
+> 補足: 単一 endpoint で `apiType` が取得できない場合、CLI は警告を出して LIST として型生成します。
+
+## Development
+
+```bash
+bun install
+npm run build
+bun run typecheck
+bun run test
+
+# 事前ビルド済み CLI を実行
+npm run start -- gen-types blog
+
+# ソースから実行（Bun）
+bun run dev gen-types blog
+
+# 単一バイナリを生成
+bun run compile
+```

package/dist/commands/gen-types/command.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveConfig, resolveOutputFilePath, resolveSingleEndpoint } from './config.js';
+import { fetchApiList, fetchApiSchema } from './management-api.js';
+import { toErrorMessage } from './shared.js';
+import { renderDefinitionsFile } from './type-generator.js';
+function getTargetEndpoints(apiList) {
+    const deduped = new Map();
+    for (const api of apiList) {
+        if (!deduped.has(api.apiEndpoint)) {
+            deduped.set(api.apiEndpoint, api);
+        }
+    }
+    return Array.from(deduped.values()).sort((a, b) => a.apiEndpoint.localeCompare(b.apiEndpoint));
+}
+function createGenerationTarget(endpoint, schema, apiType) {
+    return {
+        endpoint,
+        apiType,
+        schema: {
+            ...schema,
+            apiEndpoint: schema.apiEndpoint ?? endpoint,
+        },
+    };
+}
+function resolveApiTypeByEndpoint(apiList, endpoint) {
+    return apiList.find((item) => item.apiEndpoint === endpoint)?.apiType;
+}
+async function resolveSingleEndpointApiType(config, endpoint, schema, fetchApiListFn, warn) {
+    if (schema.apiType) {
+        return schema.apiType;
+    }
+    try {
+        const apiList = await fetchApiListFn(config);
+        return resolveApiTypeByEndpoint(apiList, endpoint);
+    }
+    catch (error) {
+        warn(`[warn] Failed to resolve apiType for "${endpoint}" from /apis: ${toErrorMessage(error)}`);
+        return undefined;
+    }
+}
+const defaultGenTypesCommandDeps = {
+    resolveOutputFilePath,
+    resolveConfig,
+    resolveSingleEndpoint,
+    fetchApiList,
+    fetchApiSchema,
+    renderDefinitionsFile,
+    mkdirSync: fs.mkdirSync,
+    writeFileSync: fs.writeFileSync,
+    warn: console.warn,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+async function runGenTypesCommand(endpointId, options, deps) {
+    try {
+        const all = Boolean(options.all);
+        if (all && endpointId) {
+            deps.warn('[warn] endpointId is ignored because --all is specified.');
+        }
+        const outputFilePath = deps.resolveOutputFilePath(options.output);
+        const config = deps.resolveConfig(options);
+        deps.mkdirSync(path.dirname(outputFilePath), { recursive: true });
+        const targets = [];
+        if (all) {
+            const apiList = getTargetEndpoints(await deps.fetchApiList(config));
+            if (apiList.length === 0) {
+                throw new Error('No endpoints found from Management API.');
+            }
+            for (const api of apiList) {
+                const schema = await deps.fetchApiSchema(config, api.apiEndpoint);
+                targets.push(createGenerationTarget(api.apiEndpoint, schema, api.apiType));
+            }
+        }
+        else {
+            const endpoint = deps.resolveSingleEndpoint(endpointId);
+            const schema = await deps.fetchApiSchema(config, endpoint);
+            const apiType = await resolveSingleEndpointApiType(config, endpoint, schema, deps.fetchApiList, deps.warn);
+            if (!apiType && !schema.apiType) {
+                deps.warn(`[warn] apiType for "${endpoint}" could not be resolved. Falling back to LIST.`);
+            }
+            targets.push(createGenerationTarget(endpoint, schema, apiType));
+        }
+        const source = deps.renderDefinitionsFile(targets);
+        deps.writeFileSync(outputFilePath, source, 'utf-8');
+        deps.log(`Generated ${targets.length} endpoint type(s): ${outputFilePath}`);
+    }
+    catch (error) {
+        deps.error('Error:', toErrorMessage(error));
+        deps.exit(1);
+    }
+}
+export function createGenTypesCommand(overrides = {}) {
+    const deps = {
+        ...defaultGenTypesCommandDeps,
+        ...overrides,
+    };
+    return async (endpointId, options) => {
+        await runGenTypesCommand(endpointId, options, deps);
+    };
+}
+export async function genTypesCommand(endpointId, options) {
+    await runGenTypesCommand(endpointId, options, defaultGenTypesCommandDeps);
+}

package/dist/commands/gen-types/config.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import { DEFAULT_OUTPUT_FILE_NAME, DEFAULT_OUTPUT_PATH } from './constants.js';
+import { toStringValue } from './shared.js';
+function isDeclarationFilePath(filePath) {
+    return filePath.toLowerCase().endsWith('.d.ts');
+}
+export function resolveOutputFilePath(outputOption) {
+    const outputPath = outputOption ?? DEFAULT_OUTPUT_PATH;
+    const resolvedPath = path.resolve(process.cwd(), outputPath);
+    if (isDeclarationFilePath(resolvedPath)) {
+        return resolvedPath;
+    }
+    return path.join(resolvedPath, DEFAULT_OUTPUT_FILE_NAME);
+}
+export function resolveConfig(options) {
+    const serviceDomain = toStringValue(options.serviceDomain) ??
+        toStringValue(process.env.MICROCMS_SERVICE_DOMAIN);
+    if (!serviceDomain) {
+        throw new Error('MICROCMS_SERVICE_DOMAIN is required. You can also pass --service-domain.');
+    }
+    const apiKey = toStringValue(options.apiKey) ??
+        toStringValue(process.env.MICROCMS_MANAGEMENT_API_KEY);
+    if (!apiKey) {
+        throw new Error('MICROCMS_MANAGEMENT_API_KEY is required. You can also pass --api-key.');
+    }
+    return { serviceDomain, apiKey };
+}
+export function resolveSingleEndpoint(endpointId) {
+    const resolved = toStringValue(endpointId);
+    if (!resolved) {
+        throw new Error('endpointId is required unless --all is specified.');
+    }
+    return resolved;
+}

package/dist/commands/gen-types/constants.js

@@ -0,0 +1,3 @@
+export const DEFAULT_OUTPUT_PATH = './types/microcms.d.ts';
+export const DEFAULT_OUTPUT_FILE_NAME = 'microcms.d.ts';
+export const MANAGEMENT_API_BASE_DOMAIN = 'microcms-management.io';

package/dist/commands/gen-types/index.js

@@ -0,0 +1 @@
+export { genTypesCommand } from './command.js';

package/dist/commands/gen-types/management-api.js

@@ -0,0 +1,131 @@
+import { MANAGEMENT_API_BASE_DOMAIN } from './constants.js';
+import { isRecord, toBooleanValue, toStringArray, toStringValue, } from './shared.js';
+function buildManagementApiUrl(serviceDomain, resourcePath) {
+    return `https://${serviceDomain}.${MANAGEMENT_API_BASE_DOMAIN}/api/v1/${resourcePath}`;
+}
+async function fetchFromManagementApi(url, apiKey) {
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'X-MICROCMS-API-KEY': apiKey,
+        },
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        if (response.status === 401) {
+            throw new Error(`Management API authentication failed (401). Check MICROCMS_MANAGEMENT_API_KEY. ${responseBody}`);
+        }
+        if (response.status === 403) {
+            throw new Error(`Management API authorization failed (403). Ensure "API情報の取得" is enabled for the key. ${responseBody}`);
+        }
+        throw new Error(`Management API request failed (${response.status} ${response.statusText}): ${responseBody}`);
+    }
+    return response.json();
+}
+function parseApiField(rawField) {
+    if (!isRecord(rawField)) {
+        return null;
+    }
+    const fieldId = toStringValue(rawField.fieldId);
+    const kind = toStringValue(rawField.kind);
+    if (!fieldId || !kind) {
+        return null;
+    }
+    return {
+        fieldId,
+        kind,
+        required: toBooleanValue(rawField.required) ?? false,
+        multipleSelect: toBooleanValue(rawField.multipleSelect) ?? false,
+        customFieldCreatedAt: toStringValue(rawField.customFieldCreatedAt),
+        customFieldCreatedAtList: toStringArray(rawField.customFieldCreatedAtList),
+    };
+}
+function parseCustomField(rawCustomField) {
+    if (!isRecord(rawCustomField)) {
+        return null;
+    }
+    const createdAt = toStringValue(rawCustomField.createdAt);
+    const fieldId = toStringValue(rawCustomField.fieldId);
+    const fields = Array.isArray(rawCustomField.fields)
+        ? rawCustomField.fields
+            .map((field) => parseApiField(field))
+            .filter((field) => field !== null)
+        : [];
+    if (!createdAt || !fieldId) {
+        return null;
+    }
+    return {
+        createdAt,
+        fieldId,
+        fields,
+    };
+}
+function parseApiSchema(rawSchema) {
+    if (!isRecord(rawSchema)) {
+        throw new Error('Management API schema response is invalid.');
+    }
+    const apiFields = Array.isArray(rawSchema.apiFields)
+        ? rawSchema.apiFields
+            .map((field) => parseApiField(field))
+            .filter((field) => field !== null)
+        : [];
+    const customFields = Array.isArray(rawSchema.customFields)
+        ? rawSchema.customFields
+            .map((field) => parseCustomField(field))
+            .filter((field) => field !== null)
+        : [];
+    return {
+        apiFields,
+        customFields,
+        apiType: toStringValue(rawSchema.apiType),
+        apiEndpoint: toStringValue(rawSchema.apiEndpoint),
+        apiName: toStringValue(rawSchema.apiName),
+    };
+}
+function parseApiListItem(rawItem) {
+    if (!isRecord(rawItem)) {
+        return null;
+    }
+    const apiEndpoint = toStringValue(rawItem.apiEndpoint) ?? toStringValue(rawItem.endpoint);
+    if (!apiEndpoint) {
+        return null;
+    }
+    return {
+        apiEndpoint,
+        apiName: toStringValue(rawItem.apiName) ?? toStringValue(rawItem.name),
+        apiType: toStringValue(rawItem.apiType) ?? toStringValue(rawItem.type),
+    };
+}
+function parseApiList(rawResponse) {
+    const candidateArrays = [];
+    if (Array.isArray(rawResponse)) {
+        candidateArrays.push(rawResponse);
+    }
+    else if (isRecord(rawResponse)) {
+        for (const key of ['apis', 'contents', 'items', 'data']) {
+            const value = rawResponse[key];
+            if (Array.isArray(value)) {
+                candidateArrays.push(value);
+            }
+        }
+    }
+    for (const items of candidateArrays) {
+        const parsedItems = items
+            .map((item) => parseApiListItem(item))
+            .filter((item) => item !== null);
+        if (parsedItems.length > 0) {
+            return parsedItems;
+        }
+    }
+    throw new Error('Failed to parse API list from Management API response.');
+}
+export async function fetchApiList(config) {
+    const url = buildManagementApiUrl(config.serviceDomain, 'apis');
+    const rawResponse = await fetchFromManagementApi(url, config.apiKey);
+    return parseApiList(rawResponse);
+}
+export async function fetchApiSchema(config, endpointId) {
+    const url = buildManagementApiUrl(config.serviceDomain, `apis/${encodeURIComponent(endpointId)}`);
+    const rawResponse = await fetchFromManagementApi(url, config.apiKey);
+    return parseApiSchema(rawResponse);
+}

package/dist/commands/gen-types/shared.js

@@ -0,0 +1,36 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function toStringValue(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function toBooleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+export function toStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const values = value
+        .map((item) => toStringValue(item))
+        .filter((item) => item !== undefined);
+    return values.length > 0 ? values : undefined;
+}
+export function toPascalCase(value) {
+    const chunks = value.split(/[^A-Za-z0-9]+/).filter((chunk) => chunk.length > 0);
+    const raw = chunks
+        .map((chunk) => `${chunk.charAt(0).toUpperCase()}${chunk.slice(1)}`)
+        .join('');
+    const safe = raw.length > 0 ? raw : 'Generated';
+    return /^[A-Za-z_$]/.test(safe) ? safe : `T${safe}`;
+}
+export function toTypePropertyName(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : JSON.stringify(value);
+}
+export function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/gen-types/type-generator.js

@@ -0,0 +1,182 @@
+import { toPascalCase, toTypePropertyName } from './shared.js';
+export function normalizeApiType(apiType) {
+    return apiType?.toUpperCase() === 'OBJECT' ? 'OBJECT' : 'LIST';
+}
+function getUniqueTypeName(baseName, context) {
+    let candidate = baseName;
+    let suffix = 2;
+    while (context.usedCustomTypeNames.has(candidate)) {
+        candidate = `${baseName}${suffix}`;
+        suffix += 1;
+    }
+    context.usedCustomTypeNames.add(candidate);
+    return candidate;
+}
+function resolveCustomFieldTypeName(createdAt, context) {
+    const existing = context.customTypeNameByCreatedAt.get(createdAt);
+    if (existing) {
+        return existing;
+    }
+    const customField = context.customFieldByCreatedAt.get(createdAt);
+    if (!customField) {
+        return undefined;
+    }
+    const baseName = `${context.endpointBaseTypeName}${toPascalCase(customField.fieldId)}CustomField`;
+    const uniqueName = getUniqueTypeName(baseName, context);
+    context.customTypeNameByCreatedAt.set(createdAt, uniqueName);
+    return uniqueName;
+}
+function emitCustomFieldType(createdAt, context) {
+    const typeName = resolveCustomFieldTypeName(createdAt, context);
+    if (!typeName) {
+        return 'Record<string, unknown>';
+    }
+    if (context.emittedCustomTypeNames.has(typeName)) {
+        return typeName;
+    }
+    if (context.processingCustomFieldIds.has(createdAt)) {
+        return 'Record<string, unknown>';
+    }
+    const customField = context.customFieldByCreatedAt.get(createdAt);
+    if (!customField) {
+        return 'Record<string, unknown>';
+    }
+    context.processingCustomFieldIds.add(createdAt);
+    const fieldLines = customField.fields.map((field) => renderTypePropertyLine(field, context));
+    const typeBlock = fieldLines.length === 0
+        ? `export type ${typeName} = Record<string, never>;`
+        : [`export type ${typeName} = {`, ...fieldLines, '};'].join('\n');
+    context.emittedCustomTypeBlocks.push(typeBlock);
+    context.emittedCustomTypeNames.add(typeName);
+    context.processingCustomFieldIds.delete(createdAt);
+    return typeName;
+}
+function resolveFieldType(field, context) {
+    switch (field.kind) {
+        case 'text':
+        case 'textArea':
+        case 'richEditor':
+        case 'richEditorV2':
+        case 'date':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'media':
+            return 'MicroCMSImage';
+        case 'mediaList':
+            return 'MicroCMSImage[]';
+        case 'relation':
+            return 'MicroCMSContentId';
+        case 'relationList':
+            return 'MicroCMSContentId[]';
+        case 'select':
+            return field.multipleSelect ? 'string[]' : 'string';
+        case 'custom':
+            if (!field.customFieldCreatedAt) {
+                return 'Record<string, unknown>';
+            }
+            return emitCustomFieldType(field.customFieldCreatedAt, context);
+        case 'repeater': {
+            const customFieldCreatedAtList = field.customFieldCreatedAtList ?? [];
+            if (customFieldCreatedAtList.length === 0) {
+                return 'Array<Record<string, unknown>>';
+            }
+            const itemTypes = customFieldCreatedAtList.map((createdAt) => {
+                const customField = context.customFieldByCreatedAt.get(createdAt);
+                if (!customField) {
+                    return 'Record<string, unknown>';
+                }
+                const customTypeName = emitCustomFieldType(createdAt, context);
+                return `({ fieldId: ${JSON.stringify(customField.fieldId)} } & ${customTypeName})`;
+            });
+            return `Array<${itemTypes.join(' | ')}>`;
+        }
+        default:
+            return 'unknown';
+    }
+}
+function renderTypePropertyLine(field, context) {
+    const propertyName = toTypePropertyName(field.fieldId);
+    const optionalMark = field.required ? '' : '?';
+    const typeExpression = resolveFieldType(field, context);
+    return `  ${propertyName}${optionalMark}: ${typeExpression};`;
+}
+function renderEndpointType(target) {
+    const endpoint = target.endpoint;
+    const apiType = normalizeApiType(target.schema.apiType ?? target.apiType);
+    const endpointBaseTypeName = toPascalCase(endpoint);
+    const context = {
+        endpointBaseTypeName,
+        customFieldByCreatedAt: new Map(target.schema.customFields.map((field) => [field.createdAt, field])),
+        customTypeNameByCreatedAt: new Map(),
+        usedCustomTypeNames: new Set(),
+        emittedCustomTypeNames: new Set(),
+        processingCustomFieldIds: new Set(),
+        emittedCustomTypeBlocks: [],
+    };
+    const schemaTypeName = `${endpointBaseTypeName}Schema`;
+    const contentTypeName = `${endpointBaseTypeName}Content`;
+    const rootFieldLines = target.schema.apiFields.map((field) => renderTypePropertyLine(field, context));
+    const responseTypeBlock = apiType === 'LIST'
+        ? `\nexport type ${endpointBaseTypeName}ListResponse = MicroCMSListResponse<${schemaTypeName}>;`
+        : '';
+    const customTypesBlock = context.emittedCustomTypeBlocks.length > 0
+        ? `${context.emittedCustomTypeBlocks.join('\n\n')}\n\n`
+        : '';
+    const schemaTypeBlock = rootFieldLines.length === 0
+        ? `export type ${schemaTypeName} = Record<string, never>;`
+        : [`export type ${schemaTypeName} = {`, ...rootFieldLines, '};'].join('\n');
+    const contentTypeBlock = apiType === 'OBJECT'
+        ? `export type ${contentTypeName} = ${schemaTypeName} & MicroCMSObjectContent;`
+        : `export type ${contentTypeName} = ${schemaTypeName} & MicroCMSListContent;`;
+    return [
+        `// Endpoint schema from Management API: ${endpoint} (${apiType})`,
+        '',
+        customTypesBlock + schemaTypeBlock,
+        '',
+        contentTypeBlock + responseTypeBlock,
+        '',
+    ].join('\n');
+}
+export function renderDefinitionsFile(targets) {
+    const sortedTargets = [...targets].sort((a, b) => a.endpoint.localeCompare(b.endpoint));
+    const commonTypesBlock = [
+        '// Generated by microcms-cli gen-types.',
+        '// Source: microCMS Management API (/api/v1/apis, /api/v1/apis/{endpoint}).',
+        '// Note: This command does not fetch content from microCMS Content API.',
+        '// DO NOT EDIT.',
+        '',
+        'export interface MicroCMSContentId {',
+        '  id: string;',
+        '}',
+        '',
+        'export interface MicroCMSDate {',
+        '  createdAt: string;',
+        '  updatedAt: string;',
+        '  publishedAt?: string;',
+        '  revisedAt?: string;',
+        '}',
+        '',
+        'export interface MicroCMSImage {',
+        '  url: string;',
+        '  width?: number;',
+        '  height?: number;',
+        '  alt?: string;',
+        '}',
+        '',
+        'export interface MicroCMSListResponse<T> {',
+        '  contents: (T & MicroCMSListContent)[];',
+        '  totalCount: number;',
+        '  limit: number;',
+        '  offset: number;',
+        '}',
+        '',
+        'export type MicroCMSListContent = MicroCMSContentId & MicroCMSDate;',
+        'export type MicroCMSObjectContent = MicroCMSDate;',
+        '',
+    ].join('\n');
+    const endpointBlocks = sortedTargets.map((target) => renderEndpointType(target)).join('\n');
+    return [commonTypesBlock, endpointBlocks].join('\n');
+}

package/dist/commands/gen-types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { genTypesCommand } from './commands/gen-types/index.js';
+const program = new Command();
+program
+    .name('microcms-cli')
+    .description('CLI for microCMS')
+    .version('0.1.0');
+program
+    .command('gen-types [endpointId]')
+    .description('Fetch API schema from microCMS Management API and generate TypeScript types')
+    .option('-o, --output <path>', 'Output path (default: ./types/microcms.d.ts)', './types/microcms.d.ts')
+    .option('--all', 'Generate types for all endpoints')
+    .option('--service-domain <domain>', 'Override MICROCMS_SERVICE_DOMAIN')
+    .option('--api-key <key>', 'Override MICROCMS_MANAGEMENT_API_KEY')
+    .action(async (endpointId, options) => {
+    await genTypesCommand(endpointId, options);
+});
+// Show help if no command is provided
+if (process.argv.length === 2) {
+    program.outputHelp();
+}
+program.parse();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@wato787/microcms-cli",
+  "version": "0.1.0",
+  "description": "AI-friendly CLI tool for microCMS, built with Bun",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "microcms-cli": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/index.js', 0o755)\"",
+    "dev": "bun src/index.ts",
+    "start": "node dist/index.js",
+    "test": "bun test",
+    "typecheck": "tsgo --noEmit",
+    "compile": "bun build ./src/index.ts --compile --outfile microcms-cli",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^24.10.13",
+    "@typescript/native-preview": "^7.0.0-dev.20260220.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "microcms",
+    "cli",
+    "bun",
+    "typescript",
+    "mcp"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}