hono-takibi 0.7.2 → 0.7.3

package/dist/cli/app.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPISpec } from '../openapi/index.js';
+import type { Result } from '../result/index.js';
+export declare function app(openAPI: OpenAPISpec, output: `${string}.ts`, test: boolean, template: boolean, basePath?: string): Promise<Result<void, string>>;

package/dist/cli/app.js

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import { ok, asyncAndThen } from '../result/index.js';
+import { readdir, writeFile } from '../fsp/index.js';
+import { fmt } from '../format/index.js';
+import { generateApp } from '../generator/zod-openapi-hono/app/index.js';
+import { zodOpenapiHonoHandler } from '../generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
+export async function app(openAPI, output, test, template, basePath) {
+    if (!(template || !output.includes('/')))
+        return ok(undefined);
+    const dir = path.dirname(output);
+    return await asyncAndThen(await fmt(generateApp(openAPI, output, basePath)), async (appCode) => asyncAndThen(await readdir(dir), async (files) => {
+        const target = path.join(dir, files.includes('index.ts') ? 'main.ts' : 'index.ts');
+        return await asyncAndThen(await writeFile(target, appCode), async () => asyncAndThen(await zodOpenapiHonoHandler(openAPI, output, test), async () => ok(undefined)));
+    }));
+}

package/dist/cli/helper/set-config.d.ts

@@ -16,6 +16,6 @@ export declare function setConfig(base: Config, cli: CliFlags): Result<{
         name: 'PascalCase' | 'camelCase';
         export: boolean;
     };
-    input: string;
-    output: string;
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
 }, string>;

package/dist/cli/index.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '../result/index.js';
+export declare function honoTakibi(): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/index.js

@@ -0,0 +1,38 @@
+import { ok, asyncAndThen } from '../result/index.js';
+import { sliceArgs } from './helper/slice-args.js';
+import { parseHelp } from './validator/parse-help.js';
+import { parseCliArgs } from './validator/parse-cli-args.js';
+import { getConfig } from '../config/index.js';
+import { setConfig } from './helper/set-config.js';
+import { takibi } from './takibi.js';
+const HELP_TEXT = `
+Usage:
+  hono-takibi <input.yaml|json> -o <routes.ts> [options]
+
+Options:
+  --export-type               Export generated type aliases
+
+  --export-schema             Export generated schema objects
+
+  --naming-case-type <PascalCase|camelCase>
+                              Casing for generated *type aliases*
+                              (default: PascalCase)
+
+  --naming-case-schema <PascalCase|camelCase>
+                              Casing for generated *schema objects*
+                              (default: PascalCase)
+
+  --template                  Generate an app file and handler stubs
+
+  --test                      Generate empty *.test.ts files for handlers
+
+  --base-path <path>          API prefix (e.g. /api)
+  
+  --help                      Show this help and exit
+`.trimStart();
+export async function honoTakibi() {
+    const args = sliceArgs(process.argv);
+    return parseHelp(args)
+        ? ok({ message: HELP_TEXT })
+        : await asyncAndThen(getConfig(), async (config) => asyncAndThen(parseCliArgs(args, config), async (cli) => asyncAndThen(setConfig(config, cli), async (finalConfig) => takibi(finalConfig, cli.template, cli.test, cli.basePath))));
+}

package/dist/cli/takibi.d.ts

@@ -0,0 +1,15 @@
+import type { Result } from '../result/types.js';
+export declare function takibi(config: {
+    schema: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    type: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
+}, template: boolean, test: boolean, basePath?: string): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/takibi.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { ok, asyncAndThen } from '../result/index.js';
+import { fmt } from '../format/index.js';
+import { parseOpenAPI } from '../openapi/parse-openapi.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/zod-openapi-hono.js';
+import { app } from './app.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+export async function takibi(config, template, test, basePath) {
+    return await asyncAndThen(await parseOpenAPI(config.input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, config)), async (code) => asyncAndThen(await mkdir(path.dirname(config.output)), async () => asyncAndThen(await writeFile(config.output, code), async () => asyncAndThen(await app(openAPI, config.output, template, test, basePath), async () => ok({
+        message: template
+            ? 'Generated code and template files written'
+            : `Generated code written to ${config.output}`,
+    }))))));
+}

package/dist/cli/types/index.d.ts

@@ -1,6 +1,6 @@
 export type CliFlags = {
-    input: string;
-    output: string;
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
     exportType?: boolean;
     exportSchema?: boolean;
     typeCase?: 'PascalCase' | 'camelCase';

package/dist/cli/validator/index.d.ts

@@ -2,3 +2,5 @@ export { parseCliArgs } from './parse-cli-args.js';
 export { parseHelp } from './parse-help.js';
 export { parseIO } from './parse-io.js';
 export { parseNaming } from './parse-naming.js';
+export { isYamlOrJson } from './is-yaml-or-json.js';
+export { isTs } from './is-ts.js';

package/dist/cli/validator/index.js

@@ -2,3 +2,5 @@ export { parseCliArgs } from './parse-cli-args.js';
 export { parseHelp } from './parse-help.js';
 export { parseIO } from './parse-io.js';
 export { parseNaming } from './parse-naming.js';
+export { isYamlOrJson } from './is-yaml-or-json.js';
+export { isTs } from './is-ts.js';

package/dist/cli/validator/is-ts.d.ts

@@ -0,0 +1 @@
+export declare function isTs(o: string): o is `${string}.ts`;

package/dist/cli/validator/is-ts.js

@@ -0,0 +1,3 @@
+export function isTs(o) {
+    return o.endsWith('.ts') && !o.endsWith('.d.ts');
+}

package/dist/cli/validator/is-yaml-or-json.d.ts

@@ -0,0 +1 @@
+export declare function isYamlOrJson(i: string): i is `${string}.yaml` | `${string}.json`;

package/dist/cli/validator/is-yaml-or-json.js

@@ -0,0 +1,3 @@
+export function isYamlOrJson(i) {
+    return i.endsWith('.yaml') || i.endsWith('.json');
+}

package/dist/cli/validator/parse-cli-args.d.ts

@@ -6,6 +6,6 @@ import type { CliFlags } from '../types/index.js';
  * @returns A Result containing the parsed flags or an error message.
  */
 export declare function parseCliArgs(args: readonly string[], config: {
-    input?: string;
-    output?: string;
+    input?: `${string}.yaml` | `${string}.json`;
+    output?: `${string}.ts`;
 }): Result<CliFlags, string>;

package/dist/cli/validator/parse-help.js

@@ -4,5 +4,5 @@
  * @returns boolean
  */
 export function parseHelp(args) {
-    return args.length === 0 || (args.length === 1 && (args[0] === '--help' || args[0] === '-h'));
+    return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
 }

package/dist/cli/validator/parse-io.d.ts

@@ -5,9 +5,9 @@ import type { Result } from '../../result/index.js';
  * @returns A Result containing the input and output file paths or an error message
  */
 export declare function parseIO(args: readonly string[], config: {
-    input?: string;
-    output?: string;
+    input?: `${string}.yaml` | `${string}.json`;
+    output?: `${string}.ts`;
 }): Result<{
-    input: string;
-    output: string;
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
 }, string>;

package/dist/cli/validator/parse-io.js

@@ -1,4 +1,5 @@
 import { ok, err } from '../../result/index.js';
+import { isTs, isYamlOrJson } from './index.js';
 /**
  * @param args - The CLI arguments
  * @param config - The configuration object containing input and output file paths
@@ -10,7 +11,10 @@ export function parseIO(args, config) {
     const cliOutput = oIdx !== -1 ? args[oIdx + 1] : undefined;
     const input = cliInput ?? config.input;
     const output = cliOutput ?? config.output;
-    return input && output
-        ? ok({ input, output })
-        : err('Usage: hono-takibi <input-file> -o <output-file>');
+    if (output) {
+        if (isYamlOrJson(input) && isTs(output)) {
+            return ok({ input, output });
+        }
+    }
+    return err('Usage: hono-takibi <input.yaml|.json> -o <output.ts>');
 }

package/dist/config/index.d.ts

@@ -8,8 +8,8 @@ export type Config = {
         name: 'PascalCase' | 'camelCase';
         export: boolean;
     };
-    input?: string;
-    output?: string;
+    input?: `${string}.yaml` | `${string}.json`;
+    output?: `${string}.ts`;
 };
 export declare const DEFAULT_CONFIG: {
     readonly schema: {

package/dist/generator/zod-openapi-hono/app/helper/get-route-maps.js

@@ -1,4 +1,4 @@
-import { generateHandlerName } from '../../handler/generators/generate-handler-name.js';
+import { handlerName } from '../../handler/generator/index.js';
 import { generateRouteName } from '../../openapi/route/generate-route-name.js';
 /**
  * Get route maps
@@ -9,9 +9,11 @@ export function getRouteMaps(openAPISpec) {
     const paths = openAPISpec.paths;
     const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
         return Object.entries(pathItem).flatMap(([method]) => {
-            const routeName = generateRouteName(method, path);
-            const handlerName = generateHandlerName(method, path);
-            return { routeName, handlerName, path };
+            return {
+                routeName: generateRouteName(method, path),
+                handlerName: handlerName(method, path),
+                path,
+            };
         });
     });
     return routeMappings;

package/dist/generator/zod-openapi-hono/app/helper/process-import-map.d.ts

@@ -1,4 +1,3 @@
-import type { Config } from '../../../../config/index.js';
 /**
  * Process import map
  * @param { { routeName: string, handlerName: string, path: string }[] } routeMappings - Route mappings
@@ -9,6 +8,6 @@ export declare function processImportMap(routeMappings: {
     routeName: string;
     handlerName: string;
     path: string;
-}[], config: Config): {
+}[], output: `${string}.ts`): {
     [importPath: string]: string[];
 };

package/dist/generator/zod-openapi-hono/app/helper/process-import-map.js

@@ -4,10 +4,10 @@
  * @param { Config } config - Config
  * @returns { { [importPath: string]: string[] } } Import map
  */
-export function processImportMap(routeMappings, config) {
+export function processImportMap(routeMappings, output) {
     const importsMap = {};
     for (const { routeName } of routeMappings) {
-        const path = config.output;
+        const path = output;
         if (!path) {
             throw new Error('Output path is required');
         }

package/dist/generator/zod-openapi-hono/app/index.d.ts

@@ -1,12 +1,11 @@
 import type { OpenAPISpec } from '../../../openapi/index.js';
-import type { Config } from '../../../config/index.js';
 /**
  * Generate app
  *
  * @function generateApp
  * @param { OpenAPISpec } openAPISpec - OpenAPI spec
- * @param { Config } config - Config
+ * @param { `${string}.ts` } output - Output file name
  * @param { string | undefined } basePath - Base path
  * @returns { string } Generated app code
  */
-export declare function generateApp(openAPISpec: OpenAPISpec, config: Config, basePath: string | undefined): string;
+export declare function generateApp(openAPISpec: OpenAPISpec, output: `${string}.ts`, basePath: string | undefined): string;

package/dist/generator/zod-openapi-hono/app/index.js

@@ -1,7 +1,7 @@
 import { generateDocs } from './docs/generate-docs.js';
 import { getHandlerImports } from '../handler/import/get-handler-imports.js';
 import { getRouteMaps } from './helper/get-route-maps.js';
-import { generateImportHandlers } from '../handler/generators/generate-import-handlers.js';
+import { importHandlers } from '../handler/generator/index.js';
 import { generateRegisterComponent } from './register-component/generate-register-component.js';
 import { generateImportRoutes } from './generators/generate-import-routes.js';
 import { generateApplyOpenapiRoutes } from './generators/generate-apply-openapi-routes.js';
@@ -16,17 +16,16 @@ const EXPORT_APP = 'export default app';
  *
  * @function generateApp
  * @param { OpenAPISpec } openAPISpec - OpenAPI spec
- * @param { Config } config - Config
+ * @param { `${string}.ts` } output - Output file name
  * @param { string | undefined } basePath - Base path
  * @returns { string } Generated app code
  */
-export function generateApp(openAPISpec, config, basePath) {
+export function generateApp(openAPISpec, output, basePath) {
     const routeMappings = getRouteMaps(openAPISpec);
-    const importsMap = processImportMap(routeMappings, config);
+    const importsMap = processImportMap(routeMappings, output);
     const importRoutes = generateImportRoutes(importsMap);
     const handlerImportsMap = getHandlerImports(routeMappings);
-    const importHandlers = generateImportHandlers(handlerImportsMap, config);
-    const importHandlersCode = importHandlers.join('\n');
+    const importHandlersCode = importHandlers(handlerImportsMap, output).join('\n');
     const applyOpenapiRoutes = generateApplyOpenapiRoutes(routeMappings);
     const openAPIHono = basePath ? `${APP}.basePath('${basePath}')` : APP;
     const app = `app${applyOpenapiRoutes}`;

package/dist/generator/zod-openapi-hono/handler/{generators/generate-handler-name.d.ts → generator/handler-name.d.ts}

@@ -4,4 +4,4 @@
  * @param { string } path - Path
  * @returns { string } Handler name
  */
-export declare function generateHandlerName(method: string, path: string): string;
+export declare function handlerName(method: string, path: string): string;

package/dist/generator/zod-openapi-hono/handler/{generators/generate-handler-name.js → generator/handler-name.js}

@@ -5,6 +5,6 @@ import { generateRouteName } from '../../openapi/route/generate-route-name.js';
  * @param { string } path - Path
  * @returns { string } Handler name
  */
-export function generateHandlerName(method, path) {
+export function handlerName(method, path) {
     return `${generateRouteName(method, path)}Handler`;
 }

package/dist/generator/zod-openapi-hono/handler/{generators/generate-handler.d.ts → generator/handler.d.ts}

@@ -4,4 +4,4 @@
  * @param { string } routeName - The name of the route.
  * @returns { string } A string of the handler function.
  */
-export declare function generateHandler(handlerName: string, routeName: string): string;
+export declare function handler(handlerName: string, routeName: string): string;

package/dist/generator/zod-openapi-hono/handler/{generators/generate-handler.js → generator/handler.js}

@@ -4,6 +4,6 @@
  * @param { string } routeName - The name of the route.
  * @returns { string } A string of the handler function.
  */
-export function generateHandler(handlerName, routeName) {
+export function handler(handlerName, routeName) {
     return `export const ${handlerName}:RouteHandler<typeof ${routeName}>=async(c)=>{}`;
 }

package/dist/generator/zod-openapi-hono/handler/{generators/generate-import-handlers.d.ts → generator/import-handlers.d.ts}

@@ -1,10 +1,9 @@
-import type { Config } from '../../../../config/index.js';
 /**
  * Generate import handlers
  * @param { { [fileName: string]: string[] } } handlerImportsMap - Handler imports map
- * @param { Config } config - Config
+ * @param { string } output - Output file path
  * @returns { string[] } Import handlers
  */
-export declare function generateImportHandlers(handlerImportsMap: {
+export declare function importHandlers(handlerImportsMap: {
     [fileName: string]: string[];
-}, config: Config): string[];
+}, output?: string): string[];

package/dist/generator/zod-openapi-hono/handler/{generators/generate-import-handlers.js → generator/import-handlers.js}

@@ -1,14 +1,14 @@
 /**
  * Generate import handlers
  * @param { { [fileName: string]: string[] } } handlerImportsMap - Handler imports map
- * @param { Config } config - Config
+ * @param { string } output - Output file path
  * @returns { string[] } Import handlers
  */
-export function generateImportHandlers(handlerImportsMap, config) {
+export function importHandlers(handlerImportsMap, output) {
     const importHandlers = [];
     for (const [fileName, handlers] of Object.entries(handlerImportsMap)) {
         const uniqueHandlers = Array.from(new Set(handlers));
-        const replacePath = config?.output?.replace(/\/[^/]+\.ts$/, '');
+        const replacePath = output?.replace(/\/[^/]+\.ts$/, '');
         const dirPath = replacePath === undefined ? '.' : replacePath;
         const handlerPath = 'handler';
         if (dirPath === '.') {

package/dist/generator/zod-openapi-hono/handler/generator/index.d.ts

@@ -0,0 +1,3 @@
+export { importHandlers } from './import-handlers.js';
+export { handlerName } from './handler-name.js';
+export { handler } from './handler.js';

package/dist/generator/zod-openapi-hono/handler/generator/index.js

@@ -0,0 +1,3 @@
+export { importHandlers } from './import-handlers.js';
+export { handlerName } from './handler-name.js';
+export { handler } from './handler.js';

package/dist/generator/zod-openapi-hono/handler/zod-openapi-hono-handler.d.ts

@@ -1,5 +1,4 @@
 import type { OpenAPISpec } from '../../../openapi/index.js';
-import type { Config } from '../../../config/index.js';
 import type { Result } from '../../../result/types.js';
 export type HandlerOutput = {
     fileName: string;
@@ -10,8 +9,8 @@ export type HandlerOutput = {
 /**
  * Generates the Zod OpenAPI Hono handler.
  * @param { OpenAPISpec } openapi - The OpenAPI specification.
- * @param { Config } config - The configuration.
+ * @param { output } output - The output directory or file path.
  * @param { boolean } test - Whether to generate the test file.
- * @returns { Promise<void> }
+ * @returns { Promise<Result<void, string>> } - A promise that resolves to a Result indicating success or failure.
  */
-export declare function zodOpenapiHonoHandler(openapi: OpenAPISpec, config: Config, test: boolean): Promise<Result<void, string>>;
+export declare function zodOpenapiHonoHandler(openapi: OpenAPISpec, output: string, test: boolean): Promise<Result<void, string>>;

package/dist/generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js

@@ -1,31 +1,29 @@
-import { generateHandler } from './generators/generate-handler.js';
+import { handler, handlerName } from './generator/index.js';
 import { generateRouteName } from '../openapi/route/generate-route-name.js';
 import { groupHandlersByFileNameHelper } from './helper/group-handlers-by-file-name-helper.js';
 import { fmt } from '../../../format/index.js';
 import { mkdir, writeFile } from '../../../fsp/index.js';
-import { generateHandlerName } from './generators/generate-handler-name.js';
 const ROUTE_HANDLER = `import type { RouteHandler } from '@hono/zod-openapi'`;
 /**
  * Generates the Zod OpenAPI Hono handler.
  * @param { OpenAPISpec } openapi - The OpenAPI specification.
- * @param { Config } config - The configuration.
+ * @param { output } output - The output directory or file path.
  * @param { boolean } test - Whether to generate the test file.
- * @returns { Promise<void> }
+ * @returns { Promise<Result<void, string>> } - A promise that resolves to a Result indicating success or failure.
  */
-export async function zodOpenapiHonoHandler(openapi, config, test) {
+export async function zodOpenapiHonoHandler(openapi, output, test) {
     const paths = openapi.paths;
     const handlers = [];
     for (const [path, pathItem] of Object.entries(paths)) {
         for (const [method] of Object.entries(pathItem)) {
             const routeName = generateRouteName(method, path);
-            const handlerName = generateHandlerName(method, path);
-            const routeHandlerContent = generateHandler(handlerName, routeName);
+            const routeHandlerContent = handler(handlerName(method, path), routeName);
             const path_name = path
                 .replace(/[\/{}-]/g, ' ')
                 .trim()
                 .split(/\s+/)[0];
-            const fileName = path_name.length === 0 ? 'index_handler.ts' : `${path_name}_handler.ts`;
-            const testFileName = path_name.length === 0 ? 'index_handler.test.ts' : `${path_name}_handler.test.ts`;
+            const fileName = path_name.length === 0 ? 'index-handler.ts' : `${path_name}-handler.ts`;
+            const testFileName = path_name.length === 0 ? 'index-handler.test.ts' : `${path_name}-handler.test.ts`;
             handlers.push({
                 fileName,
                 testFileName,
@@ -36,16 +34,16 @@ export async function zodOpenapiHonoHandler(openapi, config, test) {
     }
     const mergedHandlers = groupHandlersByFileNameHelper(handlers);
     for (const handler of mergedHandlers) {
-        const dirPath = config?.output?.replace(/\/[^/]+\.ts$/, '');
+        const dirPath = output?.replace(/\/[^/]+\.ts$/, '');
         const handlerPath = dirPath === 'index.ts' ? 'handler' : `${dirPath}/handler`;
         const mkdirResult = await mkdir(handlerPath);
         if (!mkdirResult.ok) {
             return { ok: false, error: mkdirResult.error };
         }
         const routeTypes = handler.routeNames.map((routeName) => `${routeName}`).join(', ');
-        const match = config.output?.match(/[^/]+\.ts$/);
+        const match = output?.match(/[^/]+\.ts$/);
         const matchPath = match ? match[0] : '';
-        const path = config.output === '.' || config.output === './' ? config.output : `../${matchPath}`;
+        const path = output === '.' || output === './' ? output : `../${matchPath}`;
         const importRouteTypes = routeTypes ? `import type { ${routeTypes} } from '${path}';` : '';
         const importStatements = `${ROUTE_HANDLER}\n${importRouteTypes}`;
         const fileContent = `${importStatements}\n\n${handler.routeHandlerContents.join('\n\n')}`;

package/dist/index.d.ts

@@ -1,21 +1,2 @@
 #!/usr/bin/env node
-import type { Result } from './result/types.js';
-/**
- * CLI entry point for hono-takibi
- * Usage:
- * ```
- * hono-takibi <input-file> [-o output-file]
- * ```
- * @example
- * ```bash
- * # Global install
- * npm install -g hono-takibi
- * hono-takibi openapi.yaml -o routes.ts
- *
- * # NPX usage
- * npx hono-takibi openapi.yaml -o routes.ts
- * ```
- */
-export declare function main(): Promise<Result<{
-    message: string;
-}, string>>;
+export {};

package/dist/index.js

@@ -1,40 +1,5 @@
 #!/usr/bin/env node
-import path from 'node:path';
-import { zodOpenAPIHono } from './generator/zod-openapi-hono/openapi/zod-openapi-hono.js';
-import { generateApp } from './generator/zod-openapi-hono/app/index.js';
-import { zodOpenapiHonoHandler } from './generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
-import { getConfig } from './config/index.js';
-import { fmt } from './format/index.js';
-import { parseCliArgs, parseHelp } from './cli/validator/index.js';
-import { setConfig, sliceArgs } from './cli/helper/index.js';
-import { parseOpenAPI } from './openapi/index.js';
-import { mkdir, writeFile, readdir } from './fsp/index.js';
-import { ok, err, andThen, asyncAndThen } from './result/index.js';
-const HELP_TEXT = `
-Usage:
-  hono-takibi <input.yaml|json> -o <routes.ts> [options]
-
-Options:
-  --export-type               Export generated type aliases
-
-  --export-schema             Export generated schema objects
-
-  --naming-case-type <PascalCase|camelCase>
-                              Casing for generated *type aliases*
-                              (default: PascalCase)
-
-  --naming-case-schema <PascalCase|camelCase>
-                              Casing for generated *schema objects*
-                              (default: PascalCase)
-
-  --template                  Generate an app file and handler stubs
-
-  --test                      Generate empty *.test.ts files for handlers
-
-  --base-path <path>          API prefix (e.g. /api)
-  
-  --help                      Show this help and exit
-`.trimStart();
+import { honoTakibi } from './cli/index.js';
 /**
  * CLI entry point for hono-takibi
  * Usage:
@@ -51,36 +16,7 @@ Options:
  * npx hono-takibi openapi.yaml -o routes.ts
  * ```
  */
-export async function main() {
-    const args = sliceArgs(process.argv);
-    if (parseHelp(args))
-        return ok({ message: HELP_TEXT });
-    const setting = andThen(getConfig(), (config) => andThen(parseCliArgs(args, config), (cli) => ok({ config, cli })));
-    if (!setting.ok)
-        return err(setting.error);
-    const cli = parseCliArgs(args, setting.value.config);
-    if (!cli.ok)
-        return err(cli.error);
-    const setConfigResult = setConfig(setting.value.config, cli.value);
-    if (!setConfigResult.ok)
-        return err(setConfigResult.error);
-    const config = setConfigResult.value;
-    return await asyncAndThen(await parseOpenAPI(config.input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, config)), async (code) => asyncAndThen(await mkdir(path.dirname(config.output)), async () => asyncAndThen(await writeFile(config.output, code), async () => {
-        if (cli.value.template && config.output.includes('/')) {
-            return asyncAndThen(await fmt(generateApp(openAPI, config, cli.value.basePath)), async (appCode) => asyncAndThen(await readdir(path.dirname(config.output)), async (files) => {
-                const tgt = files.includes('index.ts')
-                    ? path.join(path.dirname(config.output), 'main.ts')
-                    : path.join(path.dirname(config.output), 'index.ts');
-                return asyncAndThen(await writeFile(tgt, appCode), async () => {
-                    await zodOpenapiHonoHandler(openAPI, config, cli.value.test);
-                    return ok({ message: 'Generated code written template code' });
-                });
-            }));
-        }
-        return ok({ message: `Generated code written to ${config.output}` });
-    }))));
-}
-main().then((result) => {
+honoTakibi().then((result) => {
     if (result.ok) {
         console.log(result.value.message);
         process.exit(0);

package/dist/vite-plugin/index.d.ts

@@ -1,6 +1,6 @@
-import type { Config } from '../config/index.js';
+import { type Config } from '../config/index.js';
 import type { ViteDevServer } from 'vite';
-export default function HonoTakibiVite(settings: Config): {
+export default function HonoTakibiVite(settings?: Config): {
     name: string;
     configureServer(server: ViteDevServer): void;
 };

package/dist/vite-plugin/index.js

@@ -3,7 +3,7 @@ import { vite } from './vite.js';
 export default function HonoTakibiVite(settings) {
     const configResult = getConfig();
     if (!configResult.ok) {
-        throw new Error(configResult.error);
+        throw new Error(`Failed to load configuration: ${configResult.error}`);
     }
     const config = settings ?? configResult.value;
     return {

package/dist/vite-plugin/vite.js

@@ -27,7 +27,7 @@ export async function vite(config) {
         }
     }
     catch (e) {
-        console.error('Usage: hono-takibi <input-file> [-o output-file]');
+        console.error('Usage: hono-takibi <input.yaml|.json> -o <output.ts>');
         return false;
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "type": "module",
   "license": "MIT",
   "keywords": [