@sdk-it/cli 0.32.0 → 0.33.1

package/dist/index.js

@@ -1,13 +1,460 @@
 #!/usr/bin/env node
 
 // packages/cli/src/lib/cli.ts
-import { Command as Command6, program } from "commander";
-import { readFile as readFile2 } from "node:fs/promises";
+import { Command as Command7, program } from "commander";
+import { readJson as readJson2 } from "@sdk-it/core/file-system.js";
 
-// packages/cli/src/lib/generators/apiref.ts
+// packages/cli/src/lib/commands/init.ts
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
 import { Command } from "commander";
+import { writeFile } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+
+// packages/cli/src/lib/commands/find-framework.ts
+import { resolve } from "node:path";
+import { exist } from "@sdk-it/core/file-system.js";
+var monorepoIndicators = {
+  lerna: () => exist(resolve(process.cwd(), "lerna.json")),
+  nx: () => exist(resolve(process.cwd(), "nx.json")),
+  pnpm: () => exist(resolve(process.cwd(), "pnpm-workspace.yaml")),
+  rush: () => exist(resolve(process.cwd(), "rush.json"))
+};
+async function detectMonorepo() {
+  for (const [indicator, check] of Object.entries(monorepoIndicators)) {
+    if (await check()) {
+      return indicator;
+    }
+  }
+  return void 0;
+}
+
+// packages/cli/src/lib/commands/find-spec-file.ts
+import { resolve as resolve2 } from "node:path";
+import { exist as exist2 } from "@sdk-it/core/file-system.js";
+async function findSpecFile() {
+  const commonNames = [
+    "openapi.json",
+    "openapi.yaml",
+    "openapi.yml",
+    "swagger.json",
+    "swagger.yaml",
+    "swagger.yml",
+    "api.json",
+    "api.yaml",
+    "api.yml",
+    "spec.json",
+    "spec.yaml",
+    "spec.yml",
+    "schema.json",
+    "schema.yaml",
+    "schema.yml"
+  ];
+  for (const name of commonNames) {
+    if (await exist2(resolve2(process.cwd(), name))) {
+      return `./${name}`;
+    }
+  }
+  return void 0;
+}
+
+// packages/cli/src/lib/commands/guess-default-package-name.ts
+import { join } from "node:path";
+import { readJson } from "@sdk-it/core/file-system.js";
+async function guessTypescriptPackageName(consideringMultipleGenerator) {
+  try {
+    const packageJson = await readJson(
+      join(process.cwd(), "package.json")
+    );
+    if (packageJson.name) {
+      const match = packageJson.name.match(/^@([^/]+)/);
+      if (match) {
+        const scope = match[1];
+        return consideringMultipleGenerator ? `@${scope}/ts-sdk` : `@${scope}/sdk`;
+      }
+    }
+  } catch {
+  }
+  return consideringMultipleGenerator ? "ts-sdk" : "sdk";
+}
+
+// packages/cli/src/lib/commands/init.ts
+var specInput = async (defaultValue) => {
+  return input({
+    message: "OpenAPI or Postman specification file path:",
+    default: defaultValue || "./openapi.json"
+  });
+};
+var generatorConfigs = {
+  typescript: {
+    name: async (isMultipleGenerators = false) => {
+      const defaultName = await guessTypescriptPackageName(isMultipleGenerators);
+      return input({
+        message: "SDK package name:",
+        default: defaultName
+      });
+    },
+    spec: specInput,
+    output: async () => {
+      let defaultValue = "./ts-sdk";
+      const monorepo = await detectMonorepo();
+      if (monorepo === "nx") {
+        defaultValue = "./packages/ts-sdk";
+      }
+      return await input({
+        message: "Output directory:",
+        default: defaultValue
+      });
+    },
+    mode: async () => {
+      const options = {
+        mode: "full",
+        install: false
+      };
+      options.mode = await select({
+        message: "Generation mode:",
+        choices: [
+          {
+            name: "Full (generates package.json and tsconfig.json)",
+            value: "full"
+          },
+          {
+            name: "Minimal (generates only the client TypeScript files)",
+            value: "minimal"
+          }
+        ],
+        default: options.mode
+      });
+      if (options.mode === "full") {
+        const installDeps = await confirm({
+          message: "Install dependencies automatically?",
+          default: true
+        });
+        options.install = installDeps;
+      }
+      return options;
+    },
+    pagination: async () => {
+      let pagination = {
+        guess: false
+      };
+      const result = await confirm({
+        message: "Enable pagination support?",
+        default: false
+      });
+      if (result) {
+        pagination.guess = await confirm({
+          message: "Would you like to guess pagination parameters?",
+          default: false
+        });
+      } else {
+        pagination = false;
+      }
+      return pagination;
+    },
+    outputType: () => select({
+      message: "Endpoint output type:",
+      choices: [
+        { name: "Default", value: "default" },
+        { name: "Status", value: "status" }
+      ],
+      default: "default"
+    }),
+    readme: () => confirm({
+      message: "Generate README file?",
+      default: true
+    }),
+    defaultFormatter: () => confirm({
+      message: "Use default formatter (prettier)?",
+      default: true
+    }),
+    framework: () => input({
+      message: "Framework integrating with the SDK (optional):"
+    }),
+    formatter: () => input({
+      message: 'Custom formatter command (optional, e.g., "prettier $SDK_IT_OUTPUT --write"):'
+    })
+  },
+  python: {
+    name: () => input({
+      message: "SDK package name:",
+      default: "my-python-sdk"
+    }),
+    spec: specInput,
+    output: () => input({
+      message: "Output directory:",
+      default: "./python-sdk"
+    }),
+    mode: async () => {
+      const isMonorepo = await detectMonorepo();
+      return select({
+        message: "Generation mode:",
+        choices: [
+          {
+            name: "Full (generates complete project structure)",
+            value: "full"
+          },
+          {
+            name: "Minimal (generates only the client files)",
+            value: "minimal"
+          }
+        ],
+        default: isMonorepo ? "full" : "full"
+        // Default to full, especially for monorepos
+      }).then((value) => value);
+    },
+    formatter: () => input({
+      message: 'Custom formatter command (optional, e.g., "black $SDK_IT_OUTPUT" or "ruff format $SDK_IT_OUTPUT"):'
+    })
+  },
+  dart: {
+    name: () => input({
+      message: "SDK package name:",
+      default: "my-dart-sdk"
+    }),
+    spec: specInput,
+    output: () => input({
+      message: "Output directory:",
+      default: "./dart-sdk"
+    }),
+    mode: async () => {
+      const isMonorepo = await detectMonorepo();
+      return select({
+        message: "Generation mode:",
+        choices: [
+          {
+            name: "Full (generates complete project structure)",
+            value: "full"
+          },
+          {
+            name: "Minimal (generates only the client files)",
+            value: "minimal"
+          }
+        ],
+        default: isMonorepo ? "full" : "full"
+        // Default to full, especially for monorepos
+      }).then((value) => value);
+    },
+    pagination: async () => {
+      let pagination = {
+        guess: false
+      };
+      const result = await confirm({
+        message: "Enable pagination support?",
+        default: false
+      });
+      if (result) {
+        pagination.guess = await confirm({
+          message: "Would you like to guess pagination parameters?",
+          default: false
+        });
+      } else {
+        pagination = false;
+      }
+      return pagination;
+    }
+  }
+};
+var init = new Command("init").description("Initialize SDK-IT configuration interactively").action(async () => {
+  console.log("Welcome to SDK-IT! Let's set up your configuration.\n");
+  const possibleSpecFile = await findSpecFile();
+  const monorepo = await detectMonorepo();
+  if (possibleSpecFile) {
+    console.log(`\u{1F50D} Auto-detected API specification: ${possibleSpecFile}`);
+  }
+  if (monorepo) {
+    console.log(`\u{1F4E6} Detected monorepo setup`);
+  }
+  if (possibleSpecFile || monorepo) {
+    console.log("");
+  }
+  const config = {
+    generators: {}
+  };
+  const generators = await checkbox({
+    message: "Which SDK generators would you like to configure?",
+    loop: false,
+    instructions: false,
+    required: true,
+    choices: [
+      { name: "TypeScript", value: "typescript" },
+      { name: "Python", value: "python" },
+      { name: "Dart", value: "dart" }
+    ]
+  });
+  for (const generator of generators) {
+    console.log(`
+Configuring ${generator} generator:`);
+    if (generator === "typescript") {
+      const tsConfig = generatorConfigs.typescript;
+      const isMultipleGenerators = generators.length > 1;
+      const generatorConfig = {
+        spec: await tsConfig.spec(possibleSpecFile),
+        output: await tsConfig.output(),
+        name: await tsConfig.name(isMultipleGenerators),
+        defaultFormatter: await tsConfig.defaultFormatter(),
+        outputType: await tsConfig.outputType(),
+        readme: await tsConfig.readme(),
+        pagination: await tsConfig.pagination(),
+        ...await tsConfig.mode()
+      };
+      const customFramework = await tsConfig.framework();
+      if (customFramework) {
+        generatorConfig.framework = customFramework;
+      }
+      const customFormatter = await tsConfig.formatter();
+      if (customFormatter) {
+        generatorConfig.formatter = customFormatter;
+      }
+      config.generators.typescript = generatorConfig;
+    } else if (generator === "python") {
+      config.generators.python = {
+        spec: await generatorConfigs.python.spec(),
+        output: await generatorConfigs.python.output(),
+        mode: await generatorConfigs.python.mode(),
+        name: await generatorConfigs.python.name()
+      };
+    } else if (generator === "dart") {
+      config.generators.dart = {
+        spec: await generatorConfigs.dart.spec(),
+        output: await generatorConfigs.dart.output(),
+        mode: await generatorConfigs.dart.mode(),
+        name: await generatorConfigs.dart.name(),
+        pagination: await generatorConfigs.dart.pagination()
+      };
+    }
+  }
+  const generateReadme = await confirm({
+    message: "\nGenerate README documentation?",
+    default: true
+  });
+  if (generateReadme) {
+    const readmeSpec = await input({
+      message: "OpenAPI specification for README:",
+      default: config.generators.typescript?.spec || possibleSpecFile || "./openapi.yaml"
+    });
+    const readmeOutput = await input({
+      message: "README output file:",
+      default: "./README.md"
+    });
+    config.readme = {
+      spec: readmeSpec,
+      output: readmeOutput
+    };
+  }
+  const generateApiRef = await confirm({
+    message: "\nGenerate API reference documentation?",
+    default: false
+  });
+  if (generateApiRef) {
+    const autoDetected = await findSpecFile();
+    const apirefSpec = await input({
+      message: "OpenAPI specification for API reference:",
+      default: config.generators.typescript?.spec || autoDetected || "./openapi.yaml"
+    });
+    const apirefOutput = await input({
+      message: "API reference output directory:",
+      default: "./docs"
+    });
+    config.apiref = {
+      spec: apirefSpec,
+      output: apirefOutput
+    };
+  }
+  const configPath = resolve3(process.cwd(), "sdk-it.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  console.log(`
+\u2705 Configuration saved to ${configPath}`);
+  console.log("\n\u{1F680} Next Steps:\n");
+  console.log("1. Generate your SDK(s):");
+  console.log("   npx @sdk-it/cli");
+  if (config.generators.typescript) {
+    console.log("2. Integrate TypeScript SDK:");
+    const importName = config.generators.typescript.name.replace(
+      /[^a-zA-Z0-9]/g,
+      ""
+    );
+    const outputDir = config.generators.typescript.output.replace("./", "");
+    console.log(`   import { ${importName} } from './${outputDir}';`);
+    console.log(`   const client = new ${importName}();`);
+    console.log(`   const result = await client.request('GET /users');
+`);
+  }
+  if (config.generators.python) {
+    console.log("2. Integrate Python SDK:");
+    const outputDir = config.generators.python.output.replace("./", "");
+    console.log(`   # Add to your Python path or install locally`);
+    console.log(`   from ${outputDir} import Client`);
+    console.log(`   client = Client()`);
+    console.log(`   result = client.users.list_users()
+`);
+  }
+  if (config.generators.dart) {
+    console.log("2. Integrate Dart SDK:");
+    const outputDir = config.generators.dart.output.replace("./", "");
+    console.log(`   # Add dependency to pubspec.yaml`);
+    console.log(`   import 'package:${outputDir}/client.dart';`);
+    console.log(`   final client = Client();`);
+    console.log(`   final result = await client.users.listUsers();
+`);
+  }
+  console.log("3. Check generated documentation:");
+  const outputs = [];
+  if (config.generators.typescript)
+    outputs.push(config.generators.typescript.output);
+  if (config.generators.python) outputs.push(config.generators.python.output);
+  if (config.generators.dart) outputs.push(config.generators.dart.output);
+  outputs.forEach((output) => {
+    if (output) {
+      console.log(
+        `   \u{1F4D6} ${output}/README.md - Usage examples and API reference`
+      );
+    }
+  });
+  if (config.readme) {
+    console.log(
+      `   \u{1F4D6} ${config.readme.output} - Generated API documentation`
+    );
+  }
+  if (config.apiref) {
+    console.log(`   \u{1F310} ${config.apiref.output} - Interactive API reference`);
+  }
+  console.log("\n4. Useful commands:");
+  console.log(
+    "   npx @sdk-it/cli          # Regenerate SDKs after API changes"
+  );
+  console.log(
+    "   npx @sdk-it/cli typescript --help # See TypeScript-specific options"
+  );
+  console.log(
+    "   npx @sdk-it/cli python --help     # See Python-specific options"
+  );
+  console.log(
+    "   npx @sdk-it/cli dart --help       # See Dart-specific options"
+  );
+  console.log("\n\u{1F4A1} Tips:");
+  console.log(
+    "   \u2022 Update your API spec and re-run `npx @sdk-it/cli generate` to sync changes"
+  );
+  console.log(
+    "   \u2022 Generated SDKs include TypeScript definitions for excellent IDE support"
+  );
+  console.log(
+    "   \u2022 Check the README files for authentication and configuration options"
+  );
+  console.log("\n\u{1F4DA} Need help?");
+  console.log("   \u2022 Documentation: https://sdk-it.dev/docs");
+  console.log(
+    "   \u2022 Examples: https://github.com/JanuaryLabs/sdk-it/tree/main/docs/examples"
+  );
+  console.log("   \u2022 Issues: https://github.com/JanuaryLabs/sdk-it/issues");
+  console.log("\nHappy coding! \u{1F389}\n");
+});
+var init_default = init;
+
+// packages/cli/src/lib/generators/apiref.ts
+import { Command as Command2 } from "commander";
 import { execa } from "execa";
-import { dirname, join } from "node:path";
+import { dirname, join as join2 } from "node:path";
 
 // packages/cli/src/lib/options.ts
 import { Option } from "commander";
@@ -61,11 +508,11 @@ function parsePagination(config) {
 }
 
 // packages/cli/src/lib/generators/apiref.ts
-var apiref_default = new Command("apiref").description("Generate APIREF").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
+var apiref_default = new Command2("apiref").description("Generate APIREF").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
   await runApiRef(options.spec, options.output);
 });
 function runApiRef(spec, output) {
-  const packageDir = join(dirname(import.meta.url), "..", "..", "apiref");
+  const packageDir = join2(dirname(import.meta.url), "..", "..", "apiref");
   return execa("nx", ["run", "apiref:build", "--verbose"], {
     stdio: "inherit",
     extendEnv: true,
@@ -78,11 +525,11 @@ function runApiRef(spec, output) {
 }
 
 // packages/cli/src/lib/generators/dart.ts
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 import { execFile, execSync } from "node:child_process";
 import { generate } from "@sdk-it/dart";
 import { loadSpec } from "@sdk-it/spec";
-var dart_default = new Command2("dart").description("Generate Dart SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-n, --name <name>", "Name of the generated client", "Client").option(
+var dart_default = new Command3("dart").description("Generate Dart SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-n, --name <name>", "Name of the generated client", "Client").option(
   "--pagination <pagination>",
   'Configure pagination (e.g., "false", "true", "guess=false")',
   "true"
@@ -94,7 +541,7 @@ async function runDart(options) {
     output: options.output,
     mode: options.mode || "full",
     name: options.name,
-    pagination: parsePagination(parseDotConfig(options.pagination ?? "true")),
+    pagination: typeof options.pagination === "string" ? parsePagination(parseDotConfig(options.pagination ?? "true")) : options.pagination,
     formatCode: ({ output }) => {
       if (options.formatter) {
         const [command, ...args] = options.formatter.split(" ");
@@ -112,12 +559,12 @@ async function runDart(options) {
 }
 
 // packages/cli/src/lib/generators/python.ts
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 import { execFile as execFile2, execSync as execSync2 } from "node:child_process";
 
 // packages/python/dist/index.js
 import { readdir } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 import { snakecase as snakecase2 } from "stringcase";
 import { isEmpty, isRef as isRef2, pascalcase as pascalcase2 } from "@sdk-it/core";
 import {
@@ -1730,7 +2177,7 @@ async function generate2(openapi, settings) {
     const files = await readdir(folder, { withFileTypes: true });
     return files.map((file) => ({
       fileName: file.name,
-      filePath: join2(file.parentPath, file.name),
+      filePath: join3(file.parentPath, file.name),
       isFolder: file.isDirectory()
     }));
   };
@@ -1741,7 +2188,7 @@ async function generate2(openapi, settings) {
       className: `${pascalcase2(entry.tag)}Api`,
       methods: []
     };
-    const input = toInputs(spec, { entry, operation });
+    const input2 = toInputs(spec, { entry, operation });
     const response = toOutput(spec, operation);
     const methodName = snakecase2(
       operation.operationId || `${entry.method}_${entry.path.replace(/[^a-zA-Z0-9]/g, "_")}`
@@ -1749,16 +2196,16 @@ async function generate2(openapi, settings) {
     const returnType = response ? response.returnType : "httpx.Response";
     const docstring = operation.summary || operation.description ? `        """${operation.summary || operation.description}"""` : "";
     group.methods.push(`
-    async def ${methodName}(self${input.haveInput ? `, input_data: ${input.inputName}` : ""}) -> ${returnType}:
+    async def ${methodName}(self${input2.haveInput ? `, input_data: ${input2.inputName}` : ""}) -> ${returnType}:
 ${docstring}
         config = RequestConfig(
             method='${entry.method.toUpperCase()}',
             url='${entry.path}',
         )
 
-        ${input.haveInput ? "config = input_data.to_request_config(config)" : ""}
+        ${input2.haveInput ? "config = input_data.to_request_config(config)" : ""}
 
-        response = await self.dispatcher.${input.contentType}(config)
+        response = await self.dispatcher.${input2.contentType}(config)
         ${response ? `return await self.receiver.json(response, ${response.successModel || "None"}, ${response.errorModel || "None"})` : "return response"}
     `);
   });
@@ -1924,19 +2371,19 @@ python-dateutil>=2.8.0
   }
   await settings.writer(output, {
     "models/__init__.py": await generateModuleInit(
-      join2(output, "models"),
+      join3(output, "models"),
       settings.readFolder
     ),
     "inputs/__init__.py": await generateModuleInit(
-      join2(output, "inputs"),
+      join3(output, "inputs"),
       settings.readFolder
     ),
     "outputs/__init__.py": await generateModuleInit(
-      join2(output, "outputs"),
+      join3(output, "outputs"),
       settings.readFolder
     ),
     "api/__init__.py": await generateModuleInit(
-      join2(output, "api"),
+      join3(output, "api"),
       settings.readFolder
     ),
     "http/__init__.py": `"""HTTP utilities."""
@@ -2077,7 +2524,7 @@ ${content}`;
 
 // packages/cli/src/lib/generators/python.ts
 import { loadSpec as loadSpec2, toIR as toIR2 } from "@sdk-it/spec";
-var python_default = new Command3("python").description("Generate Python SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-n, --name <n>", "Name of the generated client", "Client").option("-v, --verbose", "Verbose output", false).option("--formatter <formatter>", "Formatter to use for the generated code").action(async (options) => {
+var python_default = new Command4("python").description("Generate Python SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-n, --name <n>", "Name of the generated client", "Client").option("-v, --verbose", "Verbose output", false).option("--formatter <formatter>", "Formatter to use for the generated code").action(async (options) => {
   await runPython(options);
 });
 async function runPython(options) {
@@ -2118,31 +2565,31 @@ async function runPython(options) {
 }
 
 // packages/cli/src/lib/generators/readme.ts
-import { Command as Command4 } from "commander";
-import { writeFile } from "node:fs/promises";
+import { Command as Command5 } from "commander";
+import { writeFile as writeFile2 } from "node:fs/promises";
 import { toReadme } from "@sdk-it/readme";
 import { loadSpec as loadSpec3, toIR as toIR3 } from "@sdk-it/spec";
-var readme_default = new Command4("readme").description("Generate README").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
+var readme_default = new Command5("readme").description("Generate README").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
   await runReadme(options.spec, options.output);
 });
 async function runReadme(specFile, output) {
   const spec = toIR3({ spec: await loadSpec3(specFile) });
   const content = toReadme(spec);
-  await writeFile(output, content, "utf-8");
+  await writeFile2(output, content, "utf-8");
 }
 
 // packages/cli/src/lib/generators/typescript.ts
-import { Command as Command5, Option as Option2 } from "commander";
+import { Command as Command6, Option as Option2 } from "commander";
 import { publish } from "libnpmpublish";
 import { execFile as execFile3, execSync as execSync3, spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import getAuthToken from "registry-auth-token";
 import { writeFiles as writeFiles2 } from "@sdk-it/core/file-system.js";
 import { loadSpec as loadSpec4 } from "@sdk-it/spec";
 import { generate as generate3 } from "@sdk-it/typescript";
-var typescript_default = new Command5("typescript").alias("ts").description("Generate TypeScript SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(false)).option(
+var typescript_default = new Command6("typescript").alias("ts").description("Generate TypeScript SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(false)).option(
   "--useTsExtension [value]",
   "Use .ts extension for generated files",
   (value) => value === "false" ? false : true,
@@ -2185,7 +2632,10 @@ async function runTypescript(options) {
   }
   const spec = await loadSpec4(options.spec);
   if (options.output) {
-    await emitLocal(spec, { ...options, output: options.output });
+    await emitLocal(spec, {
+      ...options,
+      output: options.output
+    });
   }
   if (options.publish) {
     await emitRemote(spec, {
@@ -2200,7 +2650,7 @@ async function emitLocal(spec, options) {
     output: options.output,
     mode: options.mode || "minimal",
     name: options.name,
-    pagination: parsePagination(parseDotConfig(options.pagination ?? "true")),
+    pagination: typeof options.pagination === "string" ? parsePagination(parseDotConfig(options.pagination ?? "true")) : options.pagination,
     style: {
       name: "github",
       outputType: options.outputType,
@@ -2237,7 +2687,7 @@ async function emitLocal(spec, options) {
 async function emitRemote(spec, options) {
   const registry = options.publish === "npm" ? "https://registry.npmjs.org/" : options.publish === "github" ? "https://npm.pkg.github.com/" : options.publish;
   console.log("Publishing to registry:", registry);
-  const path = join3(tmpdir(), crypto.randomUUID());
+  const path = join4(tmpdir(), crypto.randomUUID());
   await emitLocal(spec, {
     ...options,
     output: path,
@@ -2245,7 +2695,7 @@ async function emitRemote(spec, options) {
     mode: "full"
   });
   const manifest = JSON.parse(
-    await readFile(join3(path, "package.json"), "utf-8")
+    await readFile(join4(path, "package.json"), "utf-8")
   );
   const registryUrl = new URL(registry);
   const npmrc = process.env.NPM_TOKEN ? {
@@ -2262,7 +2712,7 @@ async function emitRemote(spec, options) {
   }
   const packResult = execSync3("npm pack --pack-destination .", { cwd: path });
   const [tgzName] = packResult.toString().trim().split("\n");
-  await publish(manifest, await readFile(join3(path, tgzName)), {
+  await publish(manifest, await readFile(join4(path, tgzName)), {
     registry,
     defaultTag: "latest",
     forceAuth: {
@@ -2274,11 +2724,9 @@ async function emitRemote(spec, options) {
 }
 
 // packages/cli/src/lib/cli.ts
-var generate4 = new Command6("generate").action(async (options) => {
+var generate4 = new Command7("generate").action(async (options) => {
   options.config ??= "sdk-it.json";
-  const config = await readFile2(options.config, "utf-8").then(
-    (data) => JSON.parse(data)
-  );
+  const config = await readJson2(options.config);
   const promises = [];
   if (config.generators?.typescript) {
     promises.push(
@@ -2287,13 +2735,13 @@ var generate4 = new Command6("generate").action(async (options) => {
         output: config.generators.typescript.output,
         mode: config.generators.typescript.mode,
         name: config.generators.typescript.name,
-        useTsExtension: true,
-        install: true,
+        useTsExtension: config.generators.typescript.useTsExtension ?? true,
+        install: config.generators.typescript.install ?? false,
         verbose: false,
-        defaultFormatter: true,
+        defaultFormatter: config.generators.typescript.defaultFormatter ?? true,
         outputType: "default",
-        readme: true,
-        pagination: config.generators.typescript.pagination?.toString()
+        readme: config.generators.typescript.readme ?? true,
+        pagination: config.generators.typescript.pagination
       })
     );
   }
@@ -2315,9 +2763,8 @@ var generate4 = new Command6("generate").action(async (options) => {
         output: config.generators.dart.output,
         mode: config.generators.dart.mode,
         name: config.generators.dart.name,
-        useTsExtension: false,
         verbose: false,
-        pagination: config.generators.dart.pagination?.toString()
+        pagination: config.generators.dart.pagination
       })
     );
   }
@@ -2327,8 +2774,8 @@ var generate4 = new Command6("generate").action(async (options) => {
   await Promise.all(promises);
   console.log("All configured generators completed successfully!");
 }).addCommand(typescript_default).addCommand(python_default).addCommand(dart_default).addCommand(apiref_default).addCommand(readme_default);
-var cli = program.description(`CLI tool to interact with SDK-IT.`).addCommand(generate4, { isDefault: true }).addCommand(
-  new Command6("_internal").action(() => {
+var cli = program.description(`CLI tool to interact with SDK-IT.`).addCommand(generate4, { isDefault: true }).addCommand(init_default).addCommand(
+  new Command7("_internal").action(() => {
   }),
   { hidden: true }
 ).parse(process.argv);