@f-o-t/cli 0.1.0

package/README.md

@@ -0,0 +1,410 @@
+# @f-o-t/cli
+
+CLI tool for managing FOT (Factories of Tomorrow) libraries in monorepo workspaces.
+
+## Features
+
+- **Build** - Compile TypeScript libraries with optimized bundling
+- **Dev Mode** - Watch mode for rapid development with automatic rebuilds
+- **Test** - Run tests with optional coverage and watch mode
+- **Check** - Run all checks (typecheck + test) in one command
+- **Typecheck** - TypeScript type checking without builds
+- **Generate** - Generate configuration files from `fot.config.ts`
+- **Create** - Scaffold new libraries with complete boilerplate
+
+## Installation
+
+Install as a dev dependency in your monorepo:
+
+```bash
+bun add -D @f-o-t/cli
+```
+
+## Quick Start
+
+```bash
+# Create a new library
+fot create my-library "A new library for FOT"
+
+# Build the library
+cd libraries/my-library
+fot build
+
+# Run tests
+fot test
+
+# Start development mode with watch
+fot dev
+```
+
+## Commands
+
+### `fot build`
+
+Build the current library using bunup bundler.
+
+```bash
+fot build
+```
+
+Builds TypeScript source files into the `dist/` directory with proper type declarations and source maps.
+
+**What it does:**
+- Compiles TypeScript to JavaScript
+- Generates type declaration files (.d.ts)
+- Creates source maps for debugging
+- Optimizes output for production
+
+---
+
+### `fot dev`
+
+Start development mode with file watching and automatic rebuilds.
+
+```bash
+fot dev
+```
+
+**What it does:**
+- Watches source files for changes
+- Automatically rebuilds on file changes
+- Provides fast feedback during development
+- Keeps TypeScript types in sync
+
+---
+
+### `fot test [options]`
+
+Run tests for the current library.
+
+```bash
+# Run tests once
+fot test
+
+# Run tests in watch mode
+fot test --watch
+
+# Run tests with coverage report
+fot test --coverage
+```
+
+**Options:**
+- `--watch` - Run tests in watch mode, re-running on file changes
+- `--coverage` - Generate test coverage report
+
+**What it does:**
+- Executes test files matching `*.test.ts` pattern
+- Provides detailed test output
+- Optionally generates coverage metrics
+- Integrates with Bun's native test runner
+
+---
+
+### `fot check`
+
+Run all checks (typecheck + test) in sequence.
+
+```bash
+fot check
+```
+
+**What it does:**
+- First runs TypeScript type checking
+- Then runs the full test suite
+- Exits with error if either check fails
+- Perfect for CI/CD pipelines
+
+---
+
+### `fot typecheck`
+
+Run TypeScript type checking without building.
+
+```bash
+fot typecheck
+```
+
+**What it does:**
+- Validates TypeScript types across your codebase
+- Checks for type errors without generating output files
+- Faster than a full build when you only need type validation
+- Uses your tsconfig.json configuration
+
+---
+
+### `fot generate`
+
+Generate configuration files from `fot.config.ts`.
+
+```bash
+fot generate
+```
+
+**What it does:**
+- Reads your `fot.config.ts` configuration
+- Generates `package.json` with proper dependencies and scripts
+- Creates `tsconfig.json` with TypeScript settings
+- Generates `biome.json` for code formatting and linting
+- Ensures configuration stays in sync
+
+**Use cases:**
+- After updating `fot.config.ts`
+- Setting up a new library
+- Syncing configuration across team members
+
+---
+
+### `fot create <name> [description]`
+
+Create a new library with complete scaffolding.
+
+```bash
+# Create with description
+fot create my-library "A new library for FOT"
+
+# Create with minimal setup (uses default description)
+fot create my-library
+```
+
+**Arguments:**
+- `<name>` - Library name (required, e.g., "my-library")
+- `[description]` - Optional description for the library
+
+**What it creates:**
+- `libraries/<name>/` directory structure
+- `fot.config.ts` with library configuration
+- `src/index.ts` with example code
+- `src/index.test.ts` with sample tests
+- `README.md` with documentation template
+- Generated configuration files (package.json, tsconfig.json, biome.json)
+- Installed dependencies
+
+**Example output:**
+```
+Creating library: @f-o-t/my-library
+Description: A new library for FOT
+
+Creating directory structure...
+✓ Created libraries/my-library/src
+
+Generating template files...
+✓ Created libraries/my-library/fot.config.ts
+✓ Created libraries/my-library/src/index.ts
+✓ Created libraries/my-library/src/index.test.ts
+✓ Created libraries/my-library/README.md
+
+Generating configuration files...
+✓ Generated libraries/my-library/package.json
+✓ Generated libraries/my-library/tsconfig.json
+✓ Generated libraries/my-library/biome.json
+
+Installing dependencies...
+✓ Dependencies installed
+
+✓ Library created successfully!
+```
+
+---
+
+### `fot help`
+
+Show help information with all available commands.
+
+```bash
+fot help
+# or
+fot --help
+# or
+fot -h
+```
+
+---
+
+### `fot version`
+
+Display the CLI version number.
+
+```bash
+fot version
+# or
+fot --version
+# or
+fot -v
+```
+
+## Configuration
+
+The CLI reads configuration from `fot.config.ts` in your library's root directory. This file defines:
+
+- Library name and description
+- Dependencies and peer dependencies
+- TypeScript compiler options
+- Build and output settings
+- Linting and formatting rules
+
+See [@f-o-t/config](../config/README.md) for detailed configuration options.
+
+**Example `fot.config.ts`:**
+
+```typescript
+import { defineFotConfig } from "@f-o-t/config";
+
+export default defineFotConfig({
+  name: "my-library",
+  description: "A new library for FOT",
+  dependencies: {
+    "zod": "^3.22.4",
+  },
+  tsconfig: {
+    compilerOptions: {
+      strict: true,
+      target: "ES2022",
+    },
+  },
+});
+```
+
+## CI/CD Integration
+
+The CLI is designed to work seamlessly in CI/CD pipelines. Here's an example GitHub Actions workflow:
+
+```yaml
+name: Test and Build
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run checks
+        run: |
+          cd libraries/my-library
+          fot check
+
+      - name: Build
+        run: |
+          cd libraries/my-library
+          fot build
+
+      - name: Test with coverage
+        run: |
+          cd libraries/my-library
+          fot test --coverage
+```
+
+**Pipeline best practices:**
+- Use `fot check` to run both typechecking and tests
+- Run `fot test --coverage` to track code coverage
+- Build after tests pass with `fot build`
+- Cache `node_modules` for faster CI runs
+
+## Development
+
+### Prerequisites
+
+- Bun runtime (latest version)
+- Node.js 18+ (for compatibility)
+- TypeScript 5.0+
+
+### Setup
+
+```bash
+# Clone the monorepo
+git clone <repository-url>
+
+# Install dependencies
+bun install
+
+# Navigate to CLI package
+cd libraries/cli
+
+# Build the CLI
+bun run build
+
+# Run in development mode
+bun run dev
+```
+
+### Testing the CLI
+
+```bash
+# Run tests
+bun test
+
+# Run tests with coverage
+bun test --coverage
+
+# Test the CLI locally
+./dist/index.js --help
+```
+
+### Project Structure
+
+```
+libraries/cli/
+├── src/
+│   ├── commands/         # Command implementations
+│   │   ├── build.ts     # Build command
+│   │   ├── dev.ts       # Dev command
+│   │   ├── test.ts      # Test command
+│   │   ├── check.ts     # Check command
+│   │   ├── typecheck.ts # Typecheck command
+│   │   ├── generate.ts  # Generate command
+│   │   ├── create.ts    # Create command
+│   │   └── index.ts     # Command exports
+│   ├── templates/        # Library scaffolding templates
+│   ├── builder.ts        # Build utilities
+│   ├── config-loader.ts  # Configuration loader
+│   └── index.ts          # CLI entry point
+├── dist/                 # Built output
+├── fot.config.ts         # CLI library config
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Troubleshooting
+
+### Build fails with module errors
+
+Ensure all dependencies are installed:
+```bash
+bun install
+```
+
+### TypeScript errors in development
+
+Run typecheck to see detailed errors:
+```bash
+fot typecheck
+```
+
+### Tests not running
+
+Verify test files match the pattern `*.test.ts` and are in the `src/` directory.
+
+### Configuration out of sync
+
+Regenerate configuration files:
+```bash
+fot generate
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+/**
+* Generate configuration files (package.json, tsconfig.json, biome.json) from fot.config.ts
+*
+* @param cwd - The directory containing the fot.config.ts file
+*/
+declare function generateConfigFiles(cwd: string): Promise<void>;
+/**
+* Options for building a library
+*/
+interface BuildOptions {
+	/**
+	* The working directory containing the fot.config.ts file
+	* @default process.cwd()
+	*/
+	cwd?: string;
+	/**
+	* Whether to watch for changes and rebuild
+	* @default false
+	*/
+	watch?: boolean;
+}
+/**
+* Build a library using Bun's bundler
+*
+* @param options - Build options
+* @throws {Error} If the build fails
+*/
+declare function buildLibrary(options?: BuildOptions): Promise<void>;
+/**
+* Execute the build command
+*
+* @param options - Build options
+*/
+declare function buildCommand(options?: BuildOptions): Promise<void>;
+import { ResolvedFotConfig } from "@f-o-t/config";
+/**
+* Checks if a fot.config.ts file exists in the given directory
+*
+* @param cwd - The directory to check
+* @returns True if fot.config.ts exists, false otherwise
+*/
+declare function hasFotConfig(cwd: string): boolean;
+/**
+* Loads and validates a fot.config.ts file from the given directory
+*
+* @param cwd - The directory containing the fot.config.ts file
+* @returns The resolved FOT configuration
+* @throws {Error} If the config file is not found or has no default */
+declare function loadFotConfig(cwd: string): Promise<ResolvedFotConfig>;
+export { loadFotConfig, hasFotConfig, generateConfigFiles, buildLibrary, buildCommand, BuildOptions };

package/dist/index.js

@@ -0,0 +1,453 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/builder.ts
+import { join as join2 } from "path";
+var {build: bunBuild } = globalThis.Bun;
+var {$ } = globalThis.Bun;
+
+// src/config-loader.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function hasFotConfig(cwd) {
+  const configPath = join(cwd, "fot.config.ts");
+  return existsSync(configPath);
+}
+async function loadFotConfig(cwd) {
+  const configPath = join(cwd, "fot.config.ts");
+  if (!existsSync(configPath)) {
+    throw new Error(`fot.config.ts not found in ${cwd}. Please create a fot.config.ts file.`);
+  }
+  try {
+    const configModule = await import(configPath);
+    if (!configModule.default) {
+      throw new Error(`fot.config.ts in ${cwd} must have a default export. Use 'export default defineFotConfig({ ... })'.`);
+    }
+    return configModule.default;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("fot.config.ts")) {
+      throw error;
+    }
+    throw new Error(`Failed to load fot.config.ts from ${cwd}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/builder.ts
+async function buildLibrary(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const watch = options.watch || false;
+  console.log("Loading fot.config.ts...");
+  const config = await loadFotConfig(cwd);
+  const entryPoints = [];
+  const mainEntry = join2(cwd, "src", "index.ts");
+  entryPoints.push(mainEntry);
+  for (const plugin of config.plugins) {
+    if (plugin.enabled !== false) {
+      const pluginEntry = join2(cwd, "src", "plugins", plugin.name, "index.ts");
+      entryPoints.push(pluginEntry);
+    }
+  }
+  console.log(`Building ${entryPoints.length} entry point(s)...`);
+  for (const format of config.formats) {
+    console.log(`Building ${format} format...`);
+    try {
+      const result = await bunBuild({
+        entrypoints: entryPoints,
+        outdir: join2(cwd, "dist"),
+        target: "bun",
+        format: format === "esm" ? "esm" : "cjs",
+        splitting: format === "esm",
+        minify: false,
+        sourcemap: "external",
+        external: config.external,
+        naming: {
+          entry: "[dir]/[name].js",
+          chunk: "[name]-[hash].js"
+        }
+      });
+      if (!result.success) {
+        const errors = result.logs.map((log) => log.message).join(`
+`);
+        throw new Error(`Build failed for ${format} format:
+${errors}`);
+      }
+      console.log(`\u2713 ${format} format built successfully`);
+    } catch (error) {
+      throw new Error(`Build failed for ${format} format: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  console.log("Build completed successfully!");
+  if (config.typescript.declaration) {
+    console.log("Generating TypeScript declarations...");
+    try {
+      await $`cd ${cwd} && bun tsc --emitDeclarationOnly --declaration --declarationMap --outDir dist --noEmit false`.quiet();
+      console.log("\u2713 TypeScript declarations generated");
+    } catch (error) {
+      throw new Error(`Declaration generation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (watch) {
+    console.log("Watching for changes...");
+  }
+}
+
+// src/commands/build.ts
+async function buildCommand(options = {}) {
+  try {
+    await buildLibrary(options);
+  } catch (error) {
+    console.error("Build failed:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+// src/commands/dev.ts
+async function devCommand() {
+  try {
+    console.log("Starting development mode...");
+    await buildLibrary({ watch: true });
+  } catch (error) {
+    console.error("Development mode failed:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+// src/commands/test.ts
+var {spawn } = globalThis.Bun;
+async function testCommand(options = {}) {
+  const args = ["test"];
+  if (options.coverage) {
+    args.push("--coverage");
+  }
+  if (options.watch) {
+    args.push("--watch");
+  }
+  console.log(`Running: bun ${args.join(" ")}`);
+  const proc = spawn({
+    cmd: ["bun", ...args],
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+// src/commands/check.ts
+var {spawn: spawn2 } = globalThis.Bun;
+async function checkCommand() {
+  console.log("Running Biome check with auto-fix...");
+  const proc = spawn2({
+    cmd: ["bunx", "biome", "check", "--write", "."],
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  if (exitCode === 0) {
+    console.log("\u2713 Check completed successfully");
+  } else {
+    console.error("Check failed");
+  }
+  process.exit(exitCode);
+}
+// src/commands/typecheck.ts
+var {spawn: spawn3 } = globalThis.Bun;
+async function typecheckCommand() {
+  console.log("Running TypeScript type checking...");
+  const proc = spawn3({
+    cmd: ["bunx", "tsc"],
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  if (exitCode === 0) {
+    console.log("\u2713 Type checking completed successfully");
+  } else {
+    console.error("Type checking failed");
+  }
+  process.exit(exitCode);
+}
+// src/commands/generate.ts
+import { writeFileSync } from "fs";
+import { join as join3 } from "path";
+import {
+  generatePackageJson,
+  generateTSConfig,
+  generateBiomeConfig
+} from "@f-o-t/config";
+async function generateConfigFiles(cwd) {
+  console.log("Loading fot.config.ts...");
+  const config = await loadFotConfig(cwd);
+  console.log("Generating package.json...");
+  const libraryName = cwd.split("/").pop() || "library";
+  const packageJson = generatePackageJson(libraryName, "0.1.0", config);
+  const packageJsonPath = join3(cwd, "package.json");
+  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + `
+`);
+  console.log(`\u2713 Generated ${packageJsonPath}`);
+  console.log("Generating tsconfig.json...");
+  const tsconfig = generateTSConfig(config);
+  const tsconfigPath = join3(cwd, "tsconfig.json");
+  writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + `
+`);
+  console.log(`\u2713 Generated ${tsconfigPath}`);
+  console.log("Generating biome.json...");
+  const biomeConfig = generateBiomeConfig(config);
+  const biomeConfigPath = join3(cwd, "biome.json");
+  writeFileSync(biomeConfigPath, JSON.stringify(biomeConfig, null, 2) + `
+`);
+  console.log(`\u2713 Generated ${biomeConfigPath}`);
+  console.log("All configuration files generated successfully!");
+}
+// src/commands/create.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+var {spawn: spawn4 } = globalThis.Bun;
+
+// src/templates/library.ts
+function getLibraryTemplate(name, description) {
+  const packageName = `@f-o-t/${name}`;
+  const fotConfig = `import { defineFotConfig } from "@f-o-t/config";
+
+export default defineFotConfig({
+  formats: ["esm", "cjs"],
+  external: [],
+  typescript: {
+    declaration: true,
+  },
+});
+`;
+  const indexTs = `/**
+ * ${packageName}
+ * ${description}
+ */
+
+export function hello(): string {
+  return "Hello from ${packageName}!";
+}
+`;
+  const indexTestTs = `import { describe, expect, test as it } from "bun:test";
+import { hello } from "./index";
+
+describe("${packageName}", () => {
+  it("should export hello function", () => {
+    expect(hello()).toBe("Hello from ${packageName}!");
+  });
+});
+`;
+  const readme = `# ${packageName}
+
+${description}
+
+## Installation
+
+\`\`\`bash
+# bun
+bun add ${packageName}
+
+# npm
+npm install ${packageName}
+
+# yarn
+yarn add ${packageName}
+
+# pnpm
+pnpm add ${packageName}
+\`\`\`
+
+## Quick Start
+
+\`\`\`typescript
+import { hello } from "${packageName}";
+
+console.log(hello());
+\`\`\`
+
+## API Reference
+
+### \`hello()\`
+
+Returns a greeting string.
+
+\`\`\`typescript
+const greeting = hello();
+console.log(greeting); // "Hello from ${packageName}!"
+\`\`\`
+
+## Contributing
+
+Contributions are welcome! Please check the repository for guidelines.
+
+## License
+
+MIT License - see [LICENSE](./LICENSE) file for details.
+
+## Links
+
+- [GitHub Repository](https://github.com/F-O-T/libraries)
+- [Issue Tracker](https://github.com/F-O-T/libraries/issues)
+`;
+  return {
+    fotConfig,
+    indexTs,
+    indexTestTs,
+    readme
+  };
+}
+
+// src/commands/create.ts
+async function createCommand(options) {
+  const { name, description, cwd = process.cwd() } = options;
+  console.log(`Creating library: @f-o-t/${name}`);
+  console.log(`Description: ${description}`);
+  const libraryPath = join4(cwd, "libraries", name);
+  if (existsSync2(libraryPath)) {
+    console.error(`Error: Library already exists at ${libraryPath}`);
+    process.exit(1);
+  }
+  console.log(`
+Creating directory structure...`);
+  const srcPath = join4(libraryPath, "src");
+  mkdirSync(srcPath, { recursive: true });
+  console.log(`\u2713 Created ${srcPath}`);
+  console.log(`
+Generating template files...`);
+  const templates = getLibraryTemplate(name, description);
+  const fotConfigPath = join4(libraryPath, "fot.config.ts");
+  writeFileSync2(fotConfigPath, templates.fotConfig);
+  console.log(`\u2713 Created ${fotConfigPath}`);
+  const indexTsPath = join4(srcPath, "index.ts");
+  writeFileSync2(indexTsPath, templates.indexTs);
+  console.log(`\u2713 Created ${indexTsPath}`);
+  const indexTestTsPath = join4(srcPath, "index.test.ts");
+  writeFileSync2(indexTestTsPath, templates.indexTestTs);
+  console.log(`\u2713 Created ${indexTestTsPath}`);
+  const readmePath = join4(libraryPath, "README.md");
+  writeFileSync2(readmePath, templates.readme);
+  console.log(`\u2713 Created ${readmePath}`);
+  console.log(`
+Generating configuration files...`);
+  await generateConfigFiles(libraryPath);
+  console.log(`
+Installing dependencies...`);
+  const installProc = spawn4({
+    cmd: ["bun", "install"],
+    cwd: libraryPath,
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await installProc.exited;
+  if (exitCode !== 0) {
+    console.error("Failed to install dependencies");
+    process.exit(exitCode);
+  }
+  console.log("\u2713 Dependencies installed");
+  console.log(`
+` + "=".repeat(60));
+  console.log("\u2713 Library created successfully!");
+  console.log("=".repeat(60));
+  console.log(`
+Next steps:`);
+  console.log(`  1. cd libraries/${name}`);
+  console.log("  2. Edit src/index.ts to implement your library");
+  console.log("  3. Add tests in src/index.test.ts");
+  console.log("  4. Run 'bun test' to verify tests pass");
+  console.log("  5. Run 'bun run build' to build the library");
+  console.log(`
+Happy coding! \uD83D\uDE80`);
+}
+// src/index.ts
+function printHelp() {
+  console.log(`
+FOT CLI - Build tools for monorepo libraries
+
+Usage: fot <command> [options]
+
+Commands:
+  build              Build the current library
+  dev                Start development mode with watch
+  test               Run tests
+    --watch          Run tests in watch mode
+    --coverage       Run tests with coverage
+  check              Run all checks (typecheck + test)
+  typecheck          Run TypeScript type checking
+  generate           Generate configuration files
+  create <name>      Create a new library
+    [description]    Optional description for the library
+  help, --help, -h   Show this help message
+  version, --version, -v  Show version number
+
+Examples:
+  fot build
+  fot dev
+  fot test --coverage
+  fot test --watch
+  fot create my-lib "A new library"
+  fot generate
+  fot check
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  try {
+    switch (command) {
+      case "build":
+        await buildCommand();
+        break;
+      case "dev":
+        await devCommand();
+        break;
+      case "test": {
+        const options = {
+          coverage: args.includes("--coverage"),
+          watch: args.includes("--watch")
+        };
+        await testCommand(options);
+        break;
+      }
+      case "check":
+        await checkCommand();
+        break;
+      case "typecheck":
+        await typecheckCommand();
+        break;
+      case "generate":
+        await generateConfigFiles(process.cwd());
+        break;
+      case "create": {
+        const name = args[1];
+        const description = args[2] || `A new FOT library: ${name}`;
+        const options = {
+          name,
+          description
+        };
+        await createCommand(options);
+        break;
+      }
+      case "help":
+      case "--help":
+      case "-h":
+        printHelp();
+        break;
+      case "version":
+      case "--version":
+      case "-v":
+        console.log("fot v0.1.0");
+        break;
+      case undefined:
+        printHelp();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log('Run "fot --help" for usage information');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+main();
+export {
+  loadFotConfig,
+  hasFotConfig,
+  generateConfigFiles,
+  buildLibrary,
+  buildCommand
+};
+
+//# debugId=3D1BC492518C26A964756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/builder.ts", "src/config-loader.ts", "src/commands/build.ts", "src/commands/dev.ts", "src/commands/test.ts", "src/commands/check.ts", "src/commands/typecheck.ts", "src/commands/generate.ts", "src/commands/create.ts", "src/templates/library.ts", "src/index.ts"],
  "sourcesContent": [
    "import { join } from \"node:path\";\nimport { build as bunBuild } from \"bun\";\nimport { $ } from \"bun\";\nimport type { BuildFormat } from \"@f-o-t/config\";\nimport { loadFotConfig } from \"./config-loader\";\n\n/**\n * Options for building a library\n */\nexport interface BuildOptions {\n  /**\n   * The working directory containing the fot.config.ts file\n   * @default process.cwd()\n   */\n  cwd?: string;\n  /**\n   * Whether to watch for changes and rebuild\n   * @default false\n   */\n  watch?: boolean;\n}\n\n/**\n * Build a library using Bun's bundler\n *\n * @param options - Build options\n * @throws {Error} If the build fails\n */\nexport async function buildLibrary(options: BuildOptions = {}): Promise<void> {\n  const cwd = options.cwd || process.cwd();\n  const watch = options.watch || false;\n\n  console.log(\"Loading fot.config.ts...\");\n  const config = await loadFotConfig(cwd);\n\n  // Collect all entry points (main + plugins)\n  const entryPoints: string[] = [];\n\n  // Main entry point\n  const mainEntry = join(cwd, \"src\", \"index.ts\");\n  entryPoints.push(mainEntry);\n\n  // Plugin entry points\n  for (const plugin of config.plugins) {\n    if (plugin.enabled !== false) {\n      const pluginEntry = join(cwd, \"src\", \"plugins\", plugin.name, \"index.ts\");\n      entryPoints.push(pluginEntry);\n    }\n  }\n\n  console.log(`Building ${entryPoints.length} entry point(s)...`);\n\n  // Iterate over formats and build each\n  for (const format of config.formats) {\n    console.log(`Building ${format} format...`);\n\n    try {\n      const result = await bunBuild({\n        entrypoints: entryPoints,\n        outdir: join(cwd, \"dist\"),\n        target: \"bun\",\n        format: format === \"esm\" ? \"esm\" : \"cjs\",\n        splitting: format === \"esm\",\n        minify: false,\n        sourcemap: \"external\",\n        external: config.external,\n        naming: {\n          entry: \"[dir]/[name].js\",\n          chunk: \"[name]-[hash].js\",\n        },\n      });\n\n      if (!result.success) {\n        const errors = result.logs.map((log) => log.message).join(\"\\n\");\n        throw new Error(`Build failed for ${format} format:\\n${errors}`);\n      }\n\n      console.log(`✓ ${format} format built successfully`);\n    } catch (error) {\n      throw new Error(\n        `Build failed for ${format} format: ${error instanceof Error ? error.message : String(error)}`\n      );\n    }\n  }\n\n  console.log(\"Build completed successfully!\");\n\n  // Generate TypeScript declarations if enabled\n  if (config.typescript.declaration) {\n    console.log(\"Generating TypeScript declarations...\");\n    try {\n      await $`cd ${cwd} && bun tsc --emitDeclarationOnly --declaration --declarationMap --outDir dist --noEmit false`.quiet();\n      console.log(\"✓ TypeScript declarations generated\");\n    } catch (error) {\n      throw new Error(\n        `Declaration generation failed: ${error instanceof Error ? error.message : String(error)}`\n      );\n    }\n  }\n\n  if (watch) {\n    console.log(\"Watching for changes...\");\n    // TODO: Implement watch mode in future\n  }\n}\n",
    "import { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport type { ResolvedFotConfig } from \"@f-o-t/config\";\n\n/**\n * Checks if a fot.config.ts file exists in the given directory\n *\n * @param cwd - The directory to check\n * @returns True if fot.config.ts exists, false otherwise\n */\nexport function hasFotConfig(cwd: string): boolean {\n  const configPath = join(cwd, \"fot.config.ts\");\n  return existsSync(configPath);\n}\n\n/**\n * Loads and validates a fot.config.ts file from the given directory\n *\n * @param cwd - The directory containing the fot.config.ts file\n * @returns The resolved FOT configuration\n * @throws {Error} If the config file is not found or has no default export\n */\nexport async function loadFotConfig(cwd: string): Promise<ResolvedFotConfig> {\n  const configPath = join(cwd, \"fot.config.ts\");\n\n  if (!existsSync(configPath)) {\n    throw new Error(\n      `fot.config.ts not found in ${cwd}. Please create a fot.config.ts file.`\n    );\n  }\n\n  try {\n    // Dynamic import to load the config file\n    const configModule = await import(configPath);\n\n    if (!configModule.default) {\n      throw new Error(\n        `fot.config.ts in ${cwd} must have a default export. Use 'export default defineFotConfig({ ... })'.`\n      );\n    }\n\n    return configModule.default as ResolvedFotConfig;\n  } catch (error) {\n    // If it's already our custom error, re-throw it\n    if (error instanceof Error && error.message.includes(\"fot.config.ts\")) {\n      throw error;\n    }\n\n    // Otherwise, wrap the error with more context\n    throw new Error(\n      `Failed to load fot.config.ts from ${cwd}: ${error instanceof Error ? error.message : String(error)}`\n    );\n  }\n}\n",
    "import { buildLibrary, type BuildOptions } from \"../builder\";\n\n/**\n * Execute the build command\n *\n * @param options - Build options\n */\nexport async function buildCommand(options: BuildOptions = {}): Promise<void> {\n  try {\n    await buildLibrary(options);\n  } catch (error) {\n    console.error(\n      \"Build failed:\",\n      error instanceof Error ? error.message : String(error)\n    );\n    process.exit(1);\n  }\n}\n",
    "import { buildLibrary } from \"../builder\";\n\n/**\n * Execute the dev command\n * Runs the build in watch mode for development\n */\nexport async function devCommand(): Promise<void> {\n  try {\n    console.log(\"Starting development mode...\");\n    await buildLibrary({ watch: true });\n  } catch (error) {\n    console.error(\n      \"Development mode failed:\",\n      error instanceof Error ? error.message : String(error)\n    );\n    process.exit(1);\n  }\n}\n",
    "import { spawn } from \"bun\";\n\n/**\n * Options for the test command\n */\nexport interface TestOptions {\n  /**\n   * Whether to generate coverage reports\n   * @default false\n   */\n  coverage?: boolean;\n  /**\n   * Whether to watch for changes and re-run tests\n   * @default false\n   */\n  watch?: boolean;\n}\n\n/**\n * Execute the test command\n *\n * @param options - Test options\n */\nexport async function testCommand(options: TestOptions = {}): Promise<void> {\n  const args = [\"test\"];\n\n  if (options.coverage) {\n    args.push(\"--coverage\");\n  }\n\n  if (options.watch) {\n    args.push(\"--watch\");\n  }\n\n  console.log(`Running: bun ${args.join(\" \")}`);\n\n  const proc = spawn({\n    cmd: [\"bun\", ...args],\n    stdio: [\"inherit\", \"inherit\", \"inherit\"],\n  });\n\n  const exitCode = await proc.exited;\n  process.exit(exitCode);\n}\n",
    "import { spawn } from \"bun\";\n\n/**\n * Execute the check command\n * Runs Biome to check and fix code style issues\n */\nexport async function checkCommand(): Promise<void> {\n  console.log(\"Running Biome check with auto-fix...\");\n\n  const proc = spawn({\n    cmd: [\"bunx\", \"biome\", \"check\", \"--write\", \".\"],\n    stdio: [\"inherit\", \"inherit\", \"inherit\"],\n  });\n\n  const exitCode = await proc.exited;\n\n  if (exitCode === 0) {\n    console.log(\"✓ Check completed successfully\");\n  } else {\n    console.error(\"Check failed\");\n  }\n\n  process.exit(exitCode);\n}\n",
    "import { spawn } from \"bun\";\n\n/**\n * Execute the typecheck command\n * Runs TypeScript compiler to check for type errors\n */\nexport async function typecheckCommand(): Promise<void> {\n  console.log(\"Running TypeScript type checking...\");\n\n  const proc = spawn({\n    cmd: [\"bunx\", \"tsc\"],\n    stdio: [\"inherit\", \"inherit\", \"inherit\"],\n  });\n\n  const exitCode = await proc.exited;\n\n  if (exitCode === 0) {\n    console.log(\"✓ Type checking completed successfully\");\n  } else {\n    console.error(\"Type checking failed\");\n  }\n\n  process.exit(exitCode);\n}\n",
    "import { writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport {\n  generatePackageJson,\n  generateTSConfig,\n  generateBiomeConfig,\n} from \"@f-o-t/config\";\nimport { loadFotConfig } from \"../config-loader\";\n\n/**\n * Generate configuration files (package.json, tsconfig.json, biome.json) from fot.config.ts\n *\n * @param cwd - The directory containing the fot.config.ts file\n */\nexport async function generateConfigFiles(cwd: string): Promise<void> {\n  console.log(\"Loading fot.config.ts...\");\n  const config = await loadFotConfig(cwd);\n\n  console.log(\"Generating package.json...\");\n  // Extract library name from directory name or use a default\n  const libraryName = cwd.split(\"/\").pop() || \"library\";\n  const packageJson = generatePackageJson(libraryName, \"0.1.0\", config);\n  const packageJsonPath = join(cwd, \"package.json\");\n  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + \"\\n\");\n  console.log(`✓ Generated ${packageJsonPath}`);\n\n  console.log(\"Generating tsconfig.json...\");\n  const tsconfig = generateTSConfig(config);\n  const tsconfigPath = join(cwd, \"tsconfig.json\");\n  writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + \"\\n\");\n  console.log(`✓ Generated ${tsconfigPath}`);\n\n  console.log(\"Generating biome.json...\");\n  const biomeConfig = generateBiomeConfig(config);\n  const biomeConfigPath = join(cwd, \"biome.json\");\n  writeFileSync(biomeConfigPath, JSON.stringify(biomeConfig, null, 2) + \"\\n\");\n  console.log(`✓ Generated ${biomeConfigPath}`);\n\n  console.log(\"All configuration files generated successfully!\");\n}\n",
    "import { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { spawn } from \"bun\";\nimport { getLibraryTemplate } from \"../templates/library\";\nimport { generateConfigFiles } from \"./generate\";\n\n/**\n * Options for creating a new library\n */\nexport interface CreateOptions {\n  /**\n   * Name of the library (e.g., \"my-library\")\n   */\n  name: string;\n  /**\n   * Brief description of the library\n   */\n  description: string;\n  /**\n   * Working directory (defaults to process.cwd())\n   */\n  cwd?: string;\n}\n\n/**\n * Create a new library with scaffolded files\n *\n * @param options - Create options\n */\nexport async function createCommand(options: CreateOptions): Promise<void> {\n  const { name, description, cwd = process.cwd() } = options;\n\n  console.log(`Creating library: @f-o-t/${name}`);\n  console.log(`Description: ${description}`);\n\n  // Determine library path\n  const libraryPath = join(cwd, \"libraries\", name);\n\n  // Check if library already exists\n  if (existsSync(libraryPath)) {\n    console.error(`Error: Library already exists at ${libraryPath}`);\n    process.exit(1);\n  }\n\n  // Create directory structure\n  console.log(\"\\nCreating directory structure...\");\n  const srcPath = join(libraryPath, \"src\");\n  mkdirSync(srcPath, { recursive: true });\n  console.log(`✓ Created ${srcPath}`);\n\n  // Get templates\n  console.log(\"\\nGenerating template files...\");\n  const templates = getLibraryTemplate(name, description);\n\n  // Write fot.config.ts\n  const fotConfigPath = join(libraryPath, \"fot.config.ts\");\n  writeFileSync(fotConfigPath, templates.fotConfig);\n  console.log(`✓ Created ${fotConfigPath}`);\n\n  // Write src/index.ts\n  const indexTsPath = join(srcPath, \"index.ts\");\n  writeFileSync(indexTsPath, templates.indexTs);\n  console.log(`✓ Created ${indexTsPath}`);\n\n  // Write src/index.test.ts\n  const indexTestTsPath = join(srcPath, \"index.test.ts\");\n  writeFileSync(indexTestTsPath, templates.indexTestTs);\n  console.log(`✓ Created ${indexTestTsPath}`);\n\n  // Write README.md\n  const readmePath = join(libraryPath, \"README.md\");\n  writeFileSync(readmePath, templates.readme);\n  console.log(`✓ Created ${readmePath}`);\n\n  // Generate configuration files\n  console.log(\"\\nGenerating configuration files...\");\n  await generateConfigFiles(libraryPath);\n\n  // Run bun install\n  console.log(\"\\nInstalling dependencies...\");\n  const installProc = spawn({\n    cmd: [\"bun\", \"install\"],\n    cwd: libraryPath,\n    stdio: [\"inherit\", \"inherit\", \"inherit\"],\n  });\n\n  const exitCode = await installProc.exited;\n\n  if (exitCode !== 0) {\n    console.error(\"Failed to install dependencies\");\n    process.exit(exitCode);\n  }\n\n  console.log(\"✓ Dependencies installed\");\n\n  // Show next steps\n  console.log(\"\\n\" + \"=\".repeat(60));\n  console.log(\"✓ Library created successfully!\");\n  console.log(\"=\".repeat(60));\n  console.log(\"\\nNext steps:\");\n  console.log(`  1. cd libraries/${name}`);\n  console.log(\"  2. Edit src/index.ts to implement your library\");\n  console.log(\"  3. Add tests in src/index.test.ts\");\n  console.log(\"  4. Run 'bun test' to verify tests pass\");\n  console.log(\"  5. Run 'bun run build' to build the library\");\n  console.log(\"\\nHappy coding! 🚀\");\n}\n",
    "/**\n * Templates for scaffolding new libraries\n */\n\nexport interface LibraryTemplates {\n  fotConfig: string;\n  indexTs: string;\n  indexTestTs: string;\n  readme: string;\n}\n\n/**\n * Get templates for a new library\n *\n * @param name - Library name (e.g., \"my-library\")\n * @param description - Brief description of the library\n * @returns Object containing all template files\n */\nexport function getLibraryTemplate(\n  name: string,\n  description: string\n): LibraryTemplates {\n  const packageName = `@f-o-t/${name}`;\n\n  const fotConfig = `import { defineFotConfig } from \"@f-o-t/config\";\n\nexport default defineFotConfig({\n  formats: [\"esm\", \"cjs\"],\n  external: [],\n  typescript: {\n    declaration: true,\n  },\n});\n`;\n\n  const indexTs = `/**\n * ${packageName}\n * ${description}\n */\n\nexport function hello(): string {\n  return \"Hello from ${packageName}!\";\n}\n`;\n\n  const indexTestTs = `import { describe, expect, test as it } from \"bun:test\";\nimport { hello } from \"./index\";\n\ndescribe(\"${packageName}\", () => {\n  it(\"should export hello function\", () => {\n    expect(hello()).toBe(\"Hello from ${packageName}!\");\n  });\n});\n`;\n\n  const readme = `# ${packageName}\n\n${description}\n\n## Installation\n\n\\`\\`\\`bash\n# bun\nbun add ${packageName}\n\n# npm\nnpm install ${packageName}\n\n# yarn\nyarn add ${packageName}\n\n# pnpm\npnpm add ${packageName}\n\\`\\`\\`\n\n## Quick Start\n\n\\`\\`\\`typescript\nimport { hello } from \"${packageName}\";\n\nconsole.log(hello());\n\\`\\`\\`\n\n## API Reference\n\n### \\`hello()\\`\n\nReturns a greeting string.\n\n\\`\\`\\`typescript\nconst greeting = hello();\nconsole.log(greeting); // \"Hello from ${packageName}!\"\n\\`\\`\\`\n\n## Contributing\n\nContributions are welcome! Please check the repository for guidelines.\n\n## License\n\nMIT License - see [LICENSE](./LICENSE) file for details.\n\n## Links\n\n- [GitHub Repository](https://github.com/F-O-T/libraries)\n- [Issue Tracker](https://github.com/F-O-T/libraries/issues)\n`;\n\n  return {\n    fotConfig,\n    indexTs,\n    indexTestTs,\n    readme,\n  };\n}\n",
    "#!/usr/bin/env bun\n\nimport {\n  buildCommand,\n  devCommand,\n  testCommand,\n  checkCommand,\n  typecheckCommand,\n  generateConfigFiles,\n  createCommand,\n  type TestOptions,\n  type CreateOptions,\n} from \"./commands/index\";\n\n// Export all commands and utilities\nexport { generateConfigFiles } from \"./commands/generate\";\nexport { buildCommand } from \"./commands/build\";\nexport { buildLibrary, type BuildOptions } from \"./builder\";\nexport { loadFotConfig, hasFotConfig } from \"./config-loader\";\n\nfunction printHelp() {\n  console.log(`\nFOT CLI - Build tools for monorepo libraries\n\nUsage: fot <command> [options]\n\nCommands:\n  build              Build the current library\n  dev                Start development mode with watch\n  test               Run tests\n    --watch          Run tests in watch mode\n    --coverage       Run tests with coverage\n  check              Run all checks (typecheck + test)\n  typecheck          Run TypeScript type checking\n  generate           Generate configuration files\n  create <name>      Create a new library\n    [description]    Optional description for the library\n  help, --help, -h   Show this help message\n  version, --version, -v  Show version number\n\nExamples:\n  fot build\n  fot dev\n  fot test --coverage\n  fot test --watch\n  fot create my-lib \"A new library\"\n  fot generate\n  fot check\n`);\n}\n\nasync function main() {\n  const args = process.argv.slice(2);\n  const command = args[0];\n\n  try {\n    switch (command) {\n      case \"build\":\n        await buildCommand();\n        break;\n\n      case \"dev\":\n        await devCommand();\n        break;\n\n      case \"test\": {\n        const options: TestOptions = {\n          coverage: args.includes(\"--coverage\"),\n          watch: args.includes(\"--watch\"),\n        };\n        await testCommand(options);\n        break;\n      }\n\n      case \"check\":\n        await checkCommand();\n        break;\n\n      case \"typecheck\":\n        await typecheckCommand();\n        break;\n\n      case \"generate\":\n        await generateConfigFiles(process.cwd());\n        break;\n\n      case \"create\": {\n        const name = args[1];\n        const description = args[2] || `A new FOT library: ${name}`;\n        const options: CreateOptions = {\n          name,\n          description,\n        };\n        await createCommand(options);\n        break;\n      }\n\n      case \"help\":\n      case \"--help\":\n      case \"-h\":\n        printHelp();\n        break;\n\n      case \"version\":\n      case \"--version\":\n      case \"-v\":\n        console.log(\"fot v0.1.0\");\n        break;\n\n      case undefined:\n        printHelp();\n        break;\n\n      default:\n        console.error(`Unknown command: ${command}`);\n        console.log('Run \"fot --help\" for usage information');\n        process.exit(1);\n    }\n  } catch (error) {\n    console.error(\"Error:\", error instanceof Error ? error.message : error);\n    process.exit(1);\n  }\n}\n\nmain();\n"
  ],
  "mappings": ";;;;AAAA,iBAAS;AACT;AACA;;;ACFA;AACA;AASO,SAAS,YAAY,CAAC,KAAsB;AAAA,EACjD,MAAM,aAAa,KAAK,KAAK,eAAe;AAAA,EAC5C,OAAO,WAAW,UAAU;AAAA;AAU9B,eAAsB,aAAa,CAAC,KAAyC;AAAA,EAC3E,MAAM,aAAa,KAAK,KAAK,eAAe;AAAA,EAE5C,IAAI,CAAC,WAAW,UAAU,GAAG;AAAA,IAC3B,MAAM,IAAI,MACR,8BAA8B,0CAChC;AAAA,EACF;AAAA,EAEA,IAAI;AAAA,IAEF,MAAM,eAAe,MAAa;AAAA,IAElC,IAAI,CAAC,aAAa,SAAS;AAAA,MACzB,MAAM,IAAI,MACR,oBAAoB,gFACtB;AAAA,IACF;AAAA,IAEA,OAAO,aAAa;AAAA,IACpB,OAAO,OAAO;AAAA,IAEd,IAAI,iBAAiB,SAAS,MAAM,QAAQ,SAAS,eAAe,GAAG;AAAA,MACrE,MAAM;AAAA,IACR;AAAA,IAGA,MAAM,IAAI,MACR,qCAAqC,QAAQ,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GACpG;AAAA;AAAA;;;ADvBJ,eAAsB,YAAY,CAAC,UAAwB,CAAC,GAAkB;AAAA,EAC5E,MAAM,MAAM,QAAQ,OAAO,QAAQ,IAAI;AAAA,EACvC,MAAM,QAAQ,QAAQ,SAAS;AAAA,EAE/B,QAAQ,IAAI,0BAA0B;AAAA,EACtC,MAAM,SAAS,MAAM,cAAc,GAAG;AAAA,EAGtC,MAAM,cAAwB,CAAC;AAAA,EAG/B,MAAM,YAAY,MAAK,KAAK,OAAO,UAAU;AAAA,EAC7C,YAAY,KAAK,SAAS;AAAA,EAG1B,WAAW,UAAU,OAAO,SAAS;AAAA,IACnC,IAAI,OAAO,YAAY,OAAO;AAAA,MAC5B,MAAM,cAAc,MAAK,KAAK,OAAO,WAAW,OAAO,MAAM,UAAU;AAAA,MACvE,YAAY,KAAK,WAAW;AAAA,IAC9B;AAAA,EACF;AAAA,EAEA,QAAQ,IAAI,YAAY,YAAY,0BAA0B;AAAA,EAG9D,WAAW,UAAU,OAAO,SAAS;AAAA,IACnC,QAAQ,IAAI,YAAY,kBAAkB;AAAA,IAE1C,IAAI;AAAA,MACF,MAAM,SAAS,MAAM,SAAS;AAAA,QAC5B,aAAa;AAAA,QACb,QAAQ,MAAK,KAAK,MAAM;AAAA,QACxB,QAAQ;AAAA,QACR,QAAQ,WAAW,QAAQ,QAAQ;AAAA,QACnC,WAAW,WAAW;AAAA,QACtB,QAAQ;AAAA,QACR,WAAW;AAAA,QACX,UAAU,OAAO;AAAA,QACjB,QAAQ;AAAA,UACN,OAAO;AAAA,UACP,OAAO;AAAA,QACT;AAAA,MACF,CAAC;AAAA,MAED,IAAI,CAAC,OAAO,SAAS;AAAA,QACnB,MAAM,SAAS,OAAO,KAAK,IAAI,CAAC,QAAQ,IAAI,OAAO,EAAE,KAAK;AAAA,CAAI;AAAA,QAC9D,MAAM,IAAI,MAAM,oBAAoB;AAAA,EAAmB,QAAQ;AAAA,MACjE;AAAA,MAEA,QAAQ,IAAI,UAAI,kCAAkC;AAAA,MAClD,OAAO,OAAO;AAAA,MACd,MAAM,IAAI,MACR,oBAAoB,kBAAkB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAC7F;AAAA;AAAA,EAEJ;AAAA,EAEA,QAAQ,IAAI,+BAA+B;AAAA,EAG3C,IAAI,OAAO,WAAW,aAAa;AAAA,IACjC,QAAQ,IAAI,uCAAuC;AAAA,IACnD,IAAI;AAAA,MACF,MAAM,OAAO,mGAAmG,MAAM;AAAA,MACtH,QAAQ,IAAI,0CAAoC;AAAA,MAChD,OAAO,OAAO;AAAA,MACd,MAAM,IAAI,MACR,kCAAkC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GACzF;AAAA;AAAA,EAEJ;AAAA,EAEA,IAAI,OAAO;AAAA,IACT,QAAQ,IAAI,yBAAyB;AAAA,EAEvC;AAAA;;;AEhGF,eAAsB,YAAY,CAAC,UAAwB,CAAC,GAAkB;AAAA,EAC5E,IAAI;AAAA,IACF,MAAM,aAAa,OAAO;AAAA,IAC1B,OAAO,OAAO;AAAA,IACd,QAAQ,MACN,iBACA,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CACvD;AAAA,IACA,QAAQ,KAAK,CAAC;AAAA;AAAA;;ACTlB,eAAsB,UAAU,GAAkB;AAAA,EAChD,IAAI;AAAA,IACF,QAAQ,IAAI,8BAA8B;AAAA,IAC1C,MAAM,aAAa,EAAE,OAAO,KAAK,CAAC;AAAA,IAClC,OAAO,OAAO;AAAA,IACd,QAAQ,MACN,4BACA,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CACvD;AAAA,IACA,QAAQ,KAAK,CAAC;AAAA;AAAA;;ACflB;AAuBA,eAAsB,WAAW,CAAC,UAAuB,CAAC,GAAkB;AAAA,EAC1E,MAAM,OAAO,CAAC,MAAM;AAAA,EAEpB,IAAI,QAAQ,UAAU;AAAA,IACpB,KAAK,KAAK,YAAY;AAAA,EACxB;AAAA,EAEA,IAAI,QAAQ,OAAO;AAAA,IACjB,KAAK,KAAK,SAAS;AAAA,EACrB;AAAA,EAEA,QAAQ,IAAI,gBAAgB,KAAK,KAAK,GAAG,GAAG;AAAA,EAE5C,MAAM,OAAO,MAAM;AAAA,IACjB,KAAK,CAAC,OAAO,GAAG,IAAI;AAAA,IACpB,OAAO,CAAC,WAAW,WAAW,SAAS;AAAA,EACzC,CAAC;AAAA,EAED,MAAM,WAAW,MAAM,KAAK;AAAA,EAC5B,QAAQ,KAAK,QAAQ;AAAA;;AC1CvB;AAMA,eAAsB,YAAY,GAAkB;AAAA,EAClD,QAAQ,IAAI,sCAAsC;AAAA,EAElD,MAAM,OAAO,OAAM;AAAA,IACjB,KAAK,CAAC,QAAQ,SAAS,SAAS,WAAW,GAAG;AAAA,IAC9C,OAAO,CAAC,WAAW,WAAW,SAAS;AAAA,EACzC,CAAC;AAAA,EAED,MAAM,WAAW,MAAM,KAAK;AAAA,EAE5B,IAAI,aAAa,GAAG;AAAA,IAClB,QAAQ,IAAI,qCAA+B;AAAA,EAC7C,EAAO;AAAA,IACL,QAAQ,MAAM,cAAc;AAAA;AAAA,EAG9B,QAAQ,KAAK,QAAQ;AAAA;;ACtBvB;AAMA,eAAsB,gBAAgB,GAAkB;AAAA,EACtD,QAAQ,IAAI,qCAAqC;AAAA,EAEjD,MAAM,OAAO,OAAM;AAAA,IACjB,KAAK,CAAC,QAAQ,KAAK;AAAA,IACnB,OAAO,CAAC,WAAW,WAAW,SAAS;AAAA,EACzC,CAAC;AAAA,EAED,MAAM,WAAW,MAAM,KAAK;AAAA,EAE5B,IAAI,aAAa,GAAG;AAAA,IAClB,QAAQ,IAAI,6CAAuC;AAAA,EACrD,EAAO;AAAA,IACL,QAAQ,MAAM,sBAAsB;AAAA;AAAA,EAGtC,QAAQ,KAAK,QAAQ;AAAA;;ACtBvB;AACA,iBAAS;AACT;AAAA;AAAA;AAAA;AAAA;AAYA,eAAsB,mBAAmB,CAAC,KAA4B;AAAA,EACpE,QAAQ,IAAI,0BAA0B;AAAA,EACtC,MAAM,SAAS,MAAM,cAAc,GAAG;AAAA,EAEtC,QAAQ,IAAI,4BAA4B;AAAA,EAExC,MAAM,cAAc,IAAI,MAAM,GAAG,EAAE,IAAI,KAAK;AAAA,EAC5C,MAAM,cAAc,oBAAoB,aAAa,SAAS,MAAM;AAAA,EACpE,MAAM,kBAAkB,MAAK,KAAK,cAAc;AAAA,EAChD,cAAc,iBAAiB,KAAK,UAAU,aAAa,MAAM,CAAC,IAAI;AAAA,CAAI;AAAA,EAC1E,QAAQ,IAAI,oBAAc,iBAAiB;AAAA,EAE3C,QAAQ,IAAI,6BAA6B;AAAA,EACzC,MAAM,WAAW,iBAAiB,MAAM;AAAA,EACxC,MAAM,eAAe,MAAK,KAAK,eAAe;AAAA,EAC9C,cAAc,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC,IAAI;AAAA,CAAI;AAAA,EACpE,QAAQ,IAAI,oBAAc,cAAc;AAAA,EAExC,QAAQ,IAAI,0BAA0B;AAAA,EACtC,MAAM,cAAc,oBAAoB,MAAM;AAAA,EAC9C,MAAM,kBAAkB,MAAK,KAAK,YAAY;AAAA,EAC9C,cAAc,iBAAiB,KAAK,UAAU,aAAa,MAAM,CAAC,IAAI;AAAA,CAAI;AAAA,EAC1E,QAAQ,IAAI,oBAAc,iBAAiB;AAAA,EAE3C,QAAQ,IAAI,iDAAiD;AAAA;;ACtC/D,uBAAS,yCAAuB;AAChC,iBAAS;AACT;;;ACgBO,SAAS,kBAAkB,CAChC,MACA,aACkB;AAAA,EAClB,MAAM,cAAc,UAAU;AAAA,EAE9B,MAAM,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWlB,MAAM,UAAU;AAAA,KACb;AAAA,KACA;AAAA;AAAA;AAAA;AAAA,uBAIkB;AAAA;AAAA;AAAA,EAIrB,MAAM,cAAc;AAAA;AAAA;AAAA,YAGV;AAAA;AAAA,uCAE2B;AAAA;AAAA;AAAA;AAAA,EAKrC,MAAM,SAAS,KAAK;AAAA;AAAA,EAEpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAMQ;AAAA;AAAA;AAAA,cAGI;AAAA;AAAA;AAAA,WAGH;AAAA;AAAA;AAAA,WAGA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAMc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wCAae;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBtC,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;;;ADpFF,eAAsB,aAAa,CAAC,SAAuC;AAAA,EACzE,QAAQ,MAAM,aAAa,MAAM,QAAQ,IAAI,MAAM;AAAA,EAEnD,QAAQ,IAAI,4BAA4B,MAAM;AAAA,EAC9C,QAAQ,IAAI,gBAAgB,aAAa;AAAA,EAGzC,MAAM,cAAc,MAAK,KAAK,aAAa,IAAI;AAAA,EAG/C,IAAI,YAAW,WAAW,GAAG;AAAA,IAC3B,QAAQ,MAAM,oCAAoC,aAAa;AAAA,IAC/D,QAAQ,KAAK,CAAC;AAAA,EAChB;AAAA,EAGA,QAAQ,IAAI;AAAA,gCAAmC;AAAA,EAC/C,MAAM,UAAU,MAAK,aAAa,KAAK;AAAA,EACvC,UAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACtC,QAAQ,IAAI,kBAAY,SAAS;AAAA,EAGjC,QAAQ,IAAI;AAAA,6BAAgC;AAAA,EAC5C,MAAM,YAAY,mBAAmB,MAAM,WAAW;AAAA,EAGtD,MAAM,gBAAgB,MAAK,aAAa,eAAe;AAAA,EACvD,eAAc,eAAe,UAAU,SAAS;AAAA,EAChD,QAAQ,IAAI,kBAAY,eAAe;AAAA,EAGvC,MAAM,cAAc,MAAK,SAAS,UAAU;AAAA,EAC5C,eAAc,aAAa,UAAU,OAAO;AAAA,EAC5C,QAAQ,IAAI,kBAAY,aAAa;AAAA,EAGrC,MAAM,kBAAkB,MAAK,SAAS,eAAe;AAAA,EACrD,eAAc,iBAAiB,UAAU,WAAW;AAAA,EACpD,QAAQ,IAAI,kBAAY,iBAAiB;AAAA,EAGzC,MAAM,aAAa,MAAK,aAAa,WAAW;AAAA,EAChD,eAAc,YAAY,UAAU,MAAM;AAAA,EAC1C,QAAQ,IAAI,kBAAY,YAAY;AAAA,EAGpC,QAAQ,IAAI;AAAA,kCAAqC;AAAA,EACjD,MAAM,oBAAoB,WAAW;AAAA,EAGrC,QAAQ,IAAI;AAAA,2BAA8B;AAAA,EAC1C,MAAM,cAAc,OAAM;AAAA,IACxB,KAAK,CAAC,OAAO,SAAS;AAAA,IACtB,KAAK;AAAA,IACL,OAAO,CAAC,WAAW,WAAW,SAAS;AAAA,EACzC,CAAC;AAAA,EAED,MAAM,WAAW,MAAM,YAAY;AAAA,EAEnC,IAAI,aAAa,GAAG;AAAA,IAClB,QAAQ,MAAM,gCAAgC;AAAA,IAC9C,QAAQ,KAAK,QAAQ;AAAA,EACvB;AAAA,EAEA,QAAQ,IAAI,+BAAyB;AAAA,EAGrC,QAAQ,IAAI;AAAA,IAAO,IAAI,OAAO,EAAE,CAAC;AAAA,EACjC,QAAQ,IAAI,sCAAgC;AAAA,EAC5C,QAAQ,IAAI,IAAI,OAAO,EAAE,CAAC;AAAA,EAC1B,QAAQ,IAAI;AAAA,YAAe;AAAA,EAC3B,QAAQ,IAAI,qBAAqB,MAAM;AAAA,EACvC,QAAQ,IAAI,kDAAkD;AAAA,EAC9D,QAAQ,IAAI,qCAAqC;AAAA,EACjD,QAAQ,IAAI,0CAA0C;AAAA,EACtD,QAAQ,IAAI,+CAA+C;AAAA,EAC3D,QAAQ,IAAI;AAAA,2BAAmB;AAAA;;AErFjC,SAAS,SAAS,GAAG;AAAA,EACnB,QAAQ,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CA2Bb;AAAA;AAGD,eAAe,IAAI,GAAG;AAAA,EACpB,MAAM,OAAO,QAAQ,KAAK,MAAM,CAAC;AAAA,EACjC,MAAM,UAAU,KAAK;AAAA,EAErB,IAAI;AAAA,IACF,QAAQ;AAAA,WACD;AAAA,QACH,MAAM,aAAa;AAAA,QACnB;AAAA,WAEG;AAAA,QACH,MAAM,WAAW;AAAA,QACjB;AAAA,WAEG,QAAQ;AAAA,QACX,MAAM,UAAuB;AAAA,UAC3B,UAAU,KAAK,SAAS,YAAY;AAAA,UACpC,OAAO,KAAK,SAAS,SAAS;AAAA,QAChC;AAAA,QACA,MAAM,YAAY,OAAO;AAAA,QACzB;AAAA,MACF;AAAA,WAEK;AAAA,QACH,MAAM,aAAa;AAAA,QACnB;AAAA,WAEG;AAAA,QACH,MAAM,iBAAiB;AAAA,QACvB;AAAA,WAEG;AAAA,QACH,MAAM,oBAAoB,QAAQ,IAAI,CAAC;AAAA,QACvC;AAAA,WAEG,UAAU;AAAA,QACb,MAAM,OAAO,KAAK;AAAA,QAClB,MAAM,cAAc,KAAK,MAAM,sBAAsB;AAAA,QACrD,MAAM,UAAyB;AAAA,UAC7B;AAAA,UACA;AAAA,QACF;AAAA,QACA,MAAM,cAAc,OAAO;AAAA,QAC3B;AAAA,MACF;AAAA,WAEK;AAAA,WACA;AAAA,WACA;AAAA,QACH,UAAU;AAAA,QACV;AAAA,WAEG;AAAA,WACA;AAAA,WACA;AAAA,QACH,QAAQ,IAAI,YAAY;AAAA,QACxB;AAAA,WAEG;AAAA,QACH,UAAU;AAAA,QACV;AAAA;AAAA,QAGA,QAAQ,MAAM,oBAAoB,SAAS;AAAA,QAC3C,QAAQ,IAAI,wCAAwC;AAAA,QACpD,QAAQ,KAAK,CAAC;AAAA;AAAA,IAElB,OAAO,OAAO;AAAA,IACd,QAAQ,MAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,KAAK;AAAA,IACtE,QAAQ,KAAK,CAAC;AAAA;AAAA;AAIlB,KAAK;",
  "debugId": "3D1BC492518C26A964756E2164756E21",
  "names": []
}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@f-o-t/cli",
+  "version": "0.1.0",
+  "description": "CLI tool for managing FOT libraries",
+  "type": "module",
+  "bin": {
+    "fot": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bunup",
+    "dev": "bunup --watch",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@f-o-t/config": "workspace:*",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "bunup": "^0.16.20",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  }
+}