honotan 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,372 @@
+# Honotan CLI
+
+A CLI tool for generating boilerplate code with different architectural patterns and frameworks for both API and client development.
+
+## Features
+
+### API Generation
+
+- **Architecture Patterns**
+  - Hexagonal (Ports & Adapters)
+  - Vertical Slice
+
+- **Frameworks**
+  - Hono
+  - Express _(coming soon)_
+  - Fastify _(coming soon)_
+
+- **Adapters**
+  - **Inbound**: HTTP, WebSocket
+  - **Outbound**: In-Memory Repository, Database, Cache
+
+### Client Generation
+
+- **Framework**: TanStack Router (file-based routing for React)
+- **State Management**: TanStack Store for global state
+- **Examples**: Counter UI and /hello fetch demo
+
+## Installation
+
+```bash
+npm install -g honotan-cli
+# or
+bun add -g honotan-cli
+```
+
+## Local Development
+
+To install and work on this project locally:
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/rifkyputra/honotan-cli.git
+cd honotan-cli
+```
+
+### 2. Install Dependencies
+
+Using Bun (recommended):
+
+```bash
+bun install
+```
+
+Or using npm:
+
+```bash
+npm install
+```
+
+### 3. Build the Project
+
+```bash
+bun run build
+# or
+npm run build
+```
+
+### 4. Link Locally for Testing
+
+To use the CLI globally during development:
+
+```bash
+npm link
+# or
+bun link
+```
+
+Now you can run `honotan` from anywhere on your system.
+
+### 5. Development Mode
+
+Run the CLI in watch mode (auto-reloads on changes):
+
+```bash
+bun run dev
+# or
+npm run dev
+```
+
+### 6. Type Checking
+
+```bash
+bun run check-types
+# or
+npm run check-types
+```
+
+### 7. Running Tests
+
+```bash
+bun test
+# or
+npm test
+```
+
+### Project Structure
+
+```
+honotan-cli/
+├── src/
+│   ├── commands/           # CLI command implementations
+│   │   ├── generate.ts     # Code generation logic
+│   │   ├── prompts.ts      # Interactive prompts
+│   │   └── detect-resource.ts
+│   ├── templates/          # Code templates
+│   │   ├── hexagonal/      # Hexagonal architecture templates
+│   │   └── vertical-slice/ # Vertical slice templates
+│   ├── utils/              # Utility functions
+│   ├── types.ts            # TypeScript type definitions
+│   └── index.ts            # CLI entry point
+├── dist/                   # Built files
+├── package.json
+└── tsconfig.json
+```
+
+## Usage
+
+### Generate a New API Resource
+
+```bash
+honotan generate api
+```
+
+Follow the interactive prompts to:
+
+1. Choose an architecture pattern (Hexagonal or Vertical Slice)
+2. Select an API framework (currently Hono only; Express and Fastify coming soon)
+3. Enter a resource name (e.g., "product", "user")
+4. Select inbound and outbound adapters
+5. Specify output directory
+
+### Generate a Client Project
+
+```bash
+honotan generate client
+```
+
+Generate a **complete, ready-to-run** TanStack Router + React project:
+
+1. Enter a resource/project name
+2. Specify output directory (default: "apps/<resource-name>")
+3. Get a fully configured project ready to run
+
+**What You Get:**
+
+- ✅ Complete Vite + React + TypeScript setup
+- ✅ TanStack Router with file-based routing
+- ✅ TanStack Query for server data fetching
+- ✅ TanStack Store for client-side state management
+- ✅ Tailwind CSS for styling
+- ✅ Headless UI components
+- ✅ Heroicons for beautiful icons
+- ✅ Counter example (TanStack Store)
+- ✅ Fetch /hello example (TanStack Query)
+- ✅ All configuration files
+- ✅ Ready to run with `npm install && npm run dev`
+
+### Client Structure (TanStack Router + Query + Store)
+
+Following the official TanStack Router conventions:
+
+```
+apps/<resource-name>/
+├── package.json
+├── vite.config.ts
+├── tailwind.config.js         # Tailwind CSS configuration
+├── postcss.config.js          # PostCSS configuration
+├── tsconfig.json
+├── index.html
+└── src/
+    ├── main.tsx               # App entry point
+    ├── index.css              # Tailwind CSS imports
+    ├── routeTree.gen.ts       # Auto-generated by TanStack Router
+    ├── lib/
+    │   ├── query-client.ts    # TanStack Query client
+    │   └── counter-store.ts   # TanStack Store state
+    └── routes/
+        ├── __root.tsx         # Root layout with Headless UI navigation
+        ├── index.tsx          # Home with counter & fetch examples
+        └── about.tsx          # About page
+```
+
+**Key Features:**
+
+- **File-based routing**: Routes automatically mapped from file structure
+- **Server data fetching**: TanStack Query for caching, background updates, and optimistic UI
+- **Client-side state**: TanStack Store for simple global state management
+- **Modern UI**: Tailwind CSS + Headless UI for accessible, beautiful components
+- **Icons**: Heroicons for scalable SVG icons
+- **Counter example**: Inc/dec/reset demonstrating TanStack Store with Headless UI buttons
+- **Fetch example**: Call /hello endpoint demonstrating TanStack Query
+- **Clean structure**: Minimal setup, easy to understand
+
+**Generated Files:**
+
+**Project Configuration:**
+
+- `package.json` - Dependencies (React, TanStack Router, TanStack Query, TanStack Store, Tailwind CSS, Headless UI, Heroicons)
+- `vite.config.ts` - Vite with TanStack Router plugin
+- `tailwind.config.js` - Tailwind CSS configuration
+- `postcss.config.js` - PostCSS with Tailwind and Autoprefixer
+- `tsconfig.json` - TypeScript configuration
+- `index.html` - Entry HTML
+- `.gitignore` - Git ignore patterns
+
+**Application Code:**
+
+- `src/main.tsx` - App entry point with router setup
+- `src/index.css` - Tailwind CSS imports
+- `src/lib/query-client.ts` - TanStack Query client configuration
+- `src/lib/counter-store.ts` - Global counter state with TanStack Store
+
+**Routes:**
+
+- `src/routes/__root.tsx` - Root layout with QueryClientProvider and Headless UI navigation
+- `src/routes/index.tsx` - Home page with counter (Store) and fetch (Query) examples using Headless UI
+- `src/routes/about.tsx` - About page with styled components
+
+### Add Adapters to Existing Resource
+
+```bash
+honotan add-adapter
+```
+
+Select an existing API resource and add new inbound or outbound adapters.
+
+### Utility Commands
+
+#### clean
+
+Deeply cleans the project by removing build artifacts and dependencies (`node_modules`, `dist`, `.turbo`, etc.) across the monorepo.
+
+```bash
+honotan util clean
+```
+
+Use this when you need a fresh start or are experiencing dependency/caching issues.
+
+## Examples
+
+### Generate an API Product Resource (Hexagonal)
+
+```bash
+$ honotan generate api
+
+? What would you like to do? Create a new resource
+? Architecture pattern: Hexagonal (Ports & Adapters)
+? API Framework: Hono
+? Resource name: product
+? Select inbound adapters: HTTP
+? Select outbound adapters: In-Memory Repository, Database
+? Output directory: src
+```
+
+This generates a complete product API module with:
+
+- Domain entities and ports
+- Use case implementation with tests
+- HTTP routes and controllers
+- In-memory and database repositories
+- Zod validation schemas
+
+### Generate a Client Project Example
+
+```bash
+$ honotan generate client
+
+? Output directory: my-app
+
+✅ TanStack Router project generated: my-app
+
+📁 Project structure:
+  my-app/
+  ├── package.json
+  ├── vite.config.ts
+  ├── tsconfig.json
+  ├── index.html
+  └── src/
+      ├── main.tsx
+      ├── routeTree.gen.ts (auto-generated)
+      ├── lib/counter-store.ts
+      └── routes/
+          ├── __root.tsx
+          ├── index.tsx
+          └── about.tsx
+
+📦 Next steps:
+  1. cd my-app
+  2. npm install  (or bun install)
+  3. npm run dev  (or bun run dev)
+  4. Open http://localhost:3000
+
+💡 Features:
+  - Counter with TanStack Store state management
+  - /hello fetch example
+  - File-based routing with TanStack Router
+```
+
+**What you get:**
+
+- Complete React + TypeScript + Vite project
+- TanStack Router for routing
+- TanStack Store for state management
+- Counter and fetch examples
+- Ready to run immediately
+
+## Technologies Used
+
+- **API Frameworks**: Hono (Express and Fastify coming soon)
+- **Client**: TanStack Router + TanStack Query + TanStack Store (React)
+- **UI**: Tailwind CSS + Headless UI + Heroicons
+- **Validation**: Zod
+- **Testing**: Vitest
+- **TypeScript**: Full type safety
+
+## Architecture Patterns
+
+### API Patterns
+
+#### Hexagonal (Ports & Adapters)
+
+Clean separation between domain, application, and infrastructure layers:
+
+- **Domain**: Business entities and port interfaces
+- **Application**: Use cases implementing business logic
+- **Adapters**: Framework-specific implementations (routes, repositories)
+
+#### Vertical Slice
+
+Feature-oriented structure where all code for a feature lives together:
+
+- Entity, service, routes, and tests in one directory
+- Faster navigation and easier understanding
+- Better encapsulation of feature logic
+
+### Client Pattern
+
+The client generation follows the **official TanStack Router pattern**:
+
+- **File-based routing**: Routes in `src/routes/` map directly to URLs
+- **Simple state**: TanStack Store for global state management
+- **Type safety**: Full TypeScript support throughout
+- **Minimal setup**: Counter and fetch examples to get started quickly
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Publishing
+
+This project uses GitHub Actions to automate publishing to NPM.
+
+1. **Update Version**: Bump the version in `package.json` (e.g., `npm version patch`).
+2. **Push Changes**: Push your changes to the `main` branch.
+3. **Automated Publish**: The GitHub Action will run tests and publish the new version to NPM automatically.
+
+**Note**: You must add your `NPM_TOKEN` to the repository secrets for this to work.
+
+## License
+
+MIT