nest-hex 0.2.0 → 0.3.2

package/dist/src/cli/utils/file-writer.d.ts

@@ -0,0 +1,17 @@
+/**
+* File writing utilities with conflict detection
+* Uses Bun's native APIs for faster performance
+*/
+interface WriteOptions {
+	force?: boolean;
+	dryRun?: boolean;
+}
+interface WriteResult {
+	success: boolean;
+	path: string;
+	existed: boolean;
+	written: boolean;
+	message?: string;
+}
+declare function writeFile(filePath: string, content: string, options?: WriteOptions): Promise<WriteResult>;
+export { writeFile, WriteResult, WriteOptions };

package/dist/src/cli/utils/file-writer.js

@@ -0,0 +1,100 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/cli/utils/file-writer.ts
+var exports_file_writer = {};
+__export(exports_file_writer, {
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(exports_file_writer);
+async function writeFile(filePath, content, options = {}) {
+  const { force = false, dryRun = false } = options;
+  const file = Bun.file(filePath);
+  const existed = await file.exists();
+  if (existed && !force && !dryRun) {
+    return {
+      success: false,
+      path: filePath,
+      existed: true,
+      written: false,
+      message: "File already exists. Use --force to overwrite."
+    };
+  }
+  if (dryRun) {
+    return {
+      success: true,
+      path: filePath,
+      existed,
+      written: false,
+      message: "Dry run - file not written"
+    };
+  }
+  try {
+    await Bun.write(filePath, content);
+    return {
+      success: true,
+      path: filePath,
+      existed,
+      written: true,
+      message: existed ? "File overwritten" : "File created"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      existed,
+      written: false,
+      message: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}

package/dist/src/cli/utils/linter-detector.d.ts

@@ -0,0 +1,12 @@
+interface LinterConfig {
+	type: "biome" | "prettier" | "script" | "none";
+	command?: string;
+	args?: string[];
+	description?: string;
+}
+/**
+* Detects which linter is available in the project
+* Priority: Biome > Prettier > lint script > none
+*/
+declare function detectLinter(projectRoot: string): Promise<LinterConfig>;
+export { detectLinter, LinterConfig };

package/dist/src/cli/utils/linter-detector.js

@@ -0,0 +1,128 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/cli/utils/linter-detector.ts
+var exports_linter_detector = {};
+__export(exports_linter_detector, {
+  detectLinter: () => detectLinter
+});
+module.exports = __toCommonJS(exports_linter_detector);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+async function detectLinter(projectRoot) {
+  const biomeConfigExists = import_node_fs.existsSync(import_node_path.join(projectRoot, "biome.json")) || import_node_fs.existsSync(import_node_path.join(projectRoot, "biome.jsonc"));
+  const packageJsonPath = import_node_path.join(projectRoot, "package.json");
+  let packageJson = {};
+  if (import_node_fs.existsSync(packageJsonPath)) {
+    try {
+      packageJson = JSON.parse(import_node_fs.readFileSync(packageJsonPath, "utf-8"));
+    } catch (error) {
+      console.warn(`Warning: Failed to parse package.json at ${packageJsonPath}`);
+      console.warn(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      console.warn(`Continuing with linter detection using config files only...
+`);
+    }
+  }
+  const hasBiomeDep = packageJson.devDependencies?.["@biomejs/biome"] || packageJson.devDependencies?.biome;
+  if (biomeConfigExists || hasBiomeDep) {
+    return {
+      type: "biome",
+      command: "biome",
+      args: ["check", "--write"],
+      description: "Formatting with Biome"
+    };
+  }
+  const prettierConfigFiles = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yml",
+    ".prettierrc.yaml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    "prettier.config.js",
+    "prettier.config.cjs"
+  ];
+  const prettierConfigExists = prettierConfigFiles.some((file) => import_node_fs.existsSync(import_node_path.join(projectRoot, file)));
+  const hasPrettierDep = packageJson.devDependencies?.prettier;
+  if (prettierConfigExists || hasPrettierDep) {
+    return {
+      type: "prettier",
+      command: "prettier",
+      args: ["--write"],
+      description: "Formatting with Prettier"
+    };
+  }
+  const lintScripts = packageJson.scripts;
+  if (lintScripts) {
+    if (lintScripts["lint:fix"]) {
+      return {
+        type: "script",
+        command: "bun",
+        args: ["run", "lint:fix"],
+        description: "Running lint:fix script"
+      };
+    }
+    if (lintScripts.lint) {
+      return {
+        type: "script",
+        command: "bun",
+        args: ["run", "lint"],
+        description: "Running lint script"
+      };
+    }
+  }
+  return {
+    type: "none",
+    description: "No linter detected"
+  };
+}

package/dist/src/cli/utils/linter-runner.d.ts

@@ -0,0 +1,17 @@
+interface LinterConfig {
+	type: "biome" | "prettier" | "script" | "none";
+	command?: string;
+	args?: string[];
+	description?: string;
+}
+interface LintResult {
+	success: boolean;
+	stdout: string;
+	stderr: string;
+	code: number | null;
+}
+/**
+* Runs the detected linter on specified files
+*/
+declare function runLinter(linterConfig: LinterConfig, files: string[], cwd: string): Promise<LintResult>;
+export { runLinter, LintResult };

package/dist/src/cli/utils/linter-runner.js

@@ -0,0 +1,101 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/cli/utils/linter-runner.ts
+var exports_linter_runner = {};
+__export(exports_linter_runner, {
+  runLinter: () => runLinter
+});
+module.exports = __toCommonJS(exports_linter_runner);
+var import_node_child_process = require("node:child_process");
+async function runLinter(linterConfig, files, cwd) {
+  if (linterConfig.type === "none" || !linterConfig.command || !linterConfig.args) {
+    return {
+      success: true,
+      stdout: "",
+      stderr: "",
+      code: 0
+    };
+  }
+  return new Promise((resolve) => {
+    const args = linterConfig.args || [];
+    const command = `${linterConfig.command} ${args.join(" ")} ${files.join(" ")}`;
+    import_node_child_process.exec(command, { cwd }, (error, stdout, stderr) => {
+      const noFilesProcessed = stderr.includes("No files were processed") || stdout.includes("No files were processed") || stdout.includes("Checked 0 files");
+      if (error) {
+        if (noFilesProcessed) {
+          resolve({
+            success: true,
+            stdout,
+            stderr,
+            code: 0
+          });
+        } else {
+          resolve({
+            success: false,
+            stdout,
+            stderr,
+            code: error.code ?? null
+          });
+        }
+      } else {
+        resolve({
+          success: true,
+          stdout,
+          stderr,
+          code: 0
+        });
+      }
+    });
+  });
+}

package/dist/src/cli/utils/name-transformer.d.ts

@@ -0,0 +1,18 @@
+/**
+* Name transformation utilities
+*/
+declare function toKebabCase(str: string): string;
+declare function toCamelCase(str: string): string;
+declare function toPascalCase(str: string): string;
+declare function toSnakeCase(str: string): string;
+declare function toScreamingSnakeCase(str: string): string;
+interface NameVariations {
+	original: string;
+	kebab: string;
+	camel: string;
+	pascal: string;
+	snake: string;
+	screamingSnake: string;
+}
+declare function generateNameVariations(name: string): NameVariations;
+export { toSnakeCase, toScreamingSnakeCase, toPascalCase, toKebabCase, toCamelCase, generateNameVariations, NameVariations };

package/dist/src/cli/utils/name-transformer.js

@@ -0,0 +1,90 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/cli/utils/name-transformer.ts
+var exports_name_transformer = {};
+__export(exports_name_transformer, {
+  toSnakeCase: () => toSnakeCase,
+  toScreamingSnakeCase: () => toScreamingSnakeCase,
+  toPascalCase: () => toPascalCase,
+  toKebabCase: () => toKebabCase,
+  toCamelCase: () => toCamelCase,
+  generateNameVariations: () => generateNameVariations
+});
+module.exports = __toCommonJS(exports_name_transformer);
+function toKebabCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toCamelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function toSnakeCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+function toScreamingSnakeCase(str) {
+  return toSnakeCase(str).toUpperCase();
+}
+function generateNameVariations(name) {
+  return {
+    original: name,
+    kebab: toKebabCase(name),
+    camel: toCamelCase(name),
+    pascal: toPascalCase(name),
+    snake: toSnakeCase(name),
+    screamingSnake: toScreamingSnakeCase(name)
+  };
+}

package/dist/src/cli/utils/path-resolver.d.ts

@@ -0,0 +1,5 @@
+declare function resolvePath(...segments: string[]): string;
+declare function joinPaths(...segments: string[]): string;
+declare function getRelativePath(from: string, to: string): string;
+declare function getImportPath(from: string, to: string): string;
+export { resolvePath, joinPaths, getRelativePath, getImportPath };

package/dist/src/cli/utils/path-resolver.js

@@ -0,0 +1,78 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/cli/utils/path-resolver.ts
+var exports_path_resolver = {};
+__export(exports_path_resolver, {
+  resolvePath: () => resolvePath,
+  joinPaths: () => joinPaths,
+  getRelativePath: () => getRelativePath,
+  getImportPath: () => getImportPath
+});
+module.exports = __toCommonJS(exports_path_resolver);
+var import_node_path = require("node:path");
+function resolvePath(...segments) {
+  return import_node_path.resolve(...segments);
+}
+function joinPaths(...segments) {
+  return import_node_path.join(...segments);
+}
+function getRelativePath(from, to) {
+  const relativePath = import_node_path.relative(from, to);
+  return relativePath.replace(/\\/g, "/");
+}
+function getImportPath(from, to) {
+  const relPath = getRelativePath(import_node_path.dirname(from), to);
+  const withoutExt = relPath.replace(/\.(ts|js)$/, "");
+  return withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
+}

package/dist/src/cli/utils/port-scanner.d.ts

@@ -0,0 +1,93 @@
+/**
+* Configuration types for nest-hex CLI
+*/
+interface NestHexConfig {
+	/**
+	* Output directory configuration
+	*/
+	output?: {
+		/**
+		* Directory for generated ports
+		* @default 'src/ports'
+		*/
+		portsDir?: string;
+		/**
+		* Directory for generated adapters
+		* @default 'src/adapters'
+		*/
+		adaptersDir?: string;
+	};
+	/**
+	* Naming conventions
+	*/
+	naming?: {
+		/**
+		* Suffix for port tokens
+		* @default 'PORT'
+		*/
+		portSuffix?: string;
+		/**
+		* Suffix for adapter classes
+		* @default 'Adapter'
+		*/
+		adapterSuffix?: string;
+		/**
+		* File naming case
+		* @default 'kebab'
+		*/
+		fileCase?: "kebab" | "camel" | "pascal";
+	};
+	/**
+	* Code style preferences
+	*/
+	style?: {
+		/**
+		* Indentation style
+		* @default 'tab'
+		*/
+		indent?: "tab" | 2 | 4;
+		/**
+		* Quote style
+		* @default 'single'
+		*/
+		quotes?: "single" | "double";
+		/**
+		* Use semicolons
+		* @default true
+		*/
+		semicolons?: boolean;
+	};
+	/**
+	* Custom template paths
+	*/
+	templates?: {
+		portModule?: string;
+		portToken?: string;
+		portInterface?: string;
+		portService?: string;
+		adapterModule?: string;
+		adapterService?: string;
+		adapterTypes?: string;
+	};
+}
+interface PortInfo {
+	/** Port name in kebab-case (e.g., 'object-storage') */
+	name: string;
+	/** Port name in PascalCase (e.g., 'ObjectStorage') */
+	pascalName: string;
+	/** Token name (e.g., 'OBJECT_STORAGE_PORT') */
+	tokenName: string;
+	/** Relative import path from adapter to port token file */
+	tokenImportPath: string;
+	/** Absolute path to port directory */
+	portPath: string;
+}
+/**
+* Scans the ports directory and returns information about all available ports
+*/
+declare function scanAvailablePorts(config: NestHexConfig, projectRoot?: string): PortInfo[];
+/**
+* Finds a specific port by name
+*/
+declare function findPortByName(portName: string, config: NestHexConfig, projectRoot?: string): PortInfo | null;
+export { scanAvailablePorts, findPortByName, PortInfo };