@aicgen/aicgen 1.0.2 → 1.0.5

package/README.md

@@ -55,17 +55,33 @@ npm install -g @aicgen/aicgen
 npx @aicgen/aicgen init
 ```
 
+### From Homebrew (macOS)
+
+```bash
+# Add the tap
+brew tap aicgen/aicgen
+
+# Install aicgen
+brew install aicgen
+```
+
 ### From Binary (Standalone)
 
-Download the latest binary for your platform from the [releases page](https://github.com/aicgen/aicgen/releases):
+Download the latest installer for your platform from the [releases page](https://github.com/aicgen/aicgen/releases):
 
-- **Windows**: `aicgen.exe`
-- **Linux**: `aicgen-linux`
-- **macOS**: `aicgen-macos`
+- **Windows**: `aicgen-setup-x64.exe` installer
+- **Linux (Debian/Ubuntu)**: `aicgen_amd64.deb`
+- **Linux (Fedora/RHEL)**: `aicgen_x86_64.rpm`
 
 ```bash
-# Windows
-.\aicgen.exe init
+# Windows - run the installer
+aicgen-setup-x64.exe
+
+# Linux (Debian/Ubuntu)
+sudo dpkg -i aicgen_amd64.deb
+
+# Linux (Fedora/RHEL)
+sudo rpm -i aicgen_x86_64.rpm
 ```
 
 ### From Source

package/data/architecture/bounded-contexts/context-map.md

@@ -0,0 +1,50 @@
+# Bounded Contexts
+
+## Core Principle
+
+Divide the domain into logical boundaries where a specific model applies. Each context has its own ubiquitous language, data model, and rules.
+
+## Context Mapping Patterns
+
+Relates different bounded contexts to each other.
+
+### Partnership
+
+Two contexts succeed or fail together. Teams work closely to align interfaces.
+
+### Shared Kernel
+
+Sharing a subset of the domain model (code/database) between contexts. High coupling, use sparingly (e.g., for generic Auth/IDs).
+
+### Customer/Supplier
+
+Downstream context (Customer) depends on Upstream context (Supplier). Upstream must negotiate changes with Downstream.
+
+### Conformist
+
+Downstream blindly conforms to Upstream's model without negotiation.
+
+### Anticorruption Layer (ACL)
+
+Downstream isolates itself from Upstream's model by translating it into its own internal model.
+
+## Implementation Structure
+
+```typescript
+// Context: Sales
+namespace Sales {
+  export class Order { ... } // Sales-specific Order model
+}
+
+// Context: Shipping
+namespace Shipping {
+  export class Shipment { ... }
+  // Shipping might interact with Sales via ACL or events
+}
+```
+
+## Best Practices
+
+- **Explicit Boundaries**: Code for one context should not bleed into another.
+- **Ubiquitous Language**: Use the same terminology in code as functionality.
+- **Decoupled Deployment**: Ideally, contexts can be deployed independently (microservices or modular monoliths).

package/data/architecture/bounded-contexts/index.md

@@ -0,0 +1,7 @@
+# Bounded Contexts
+
+Domain-Driven Design (DDD) patterns for defining explicit model boundaries.
+
+## Guidelines
+
+- `context-map` - Context Mapping patterns (Partnership, Shared Kernel, ACL) ([context-map.md](context-map.md))

package/data/architecture/component-based/index.md

@@ -0,0 +1,7 @@
+# Component-Based Architecture
+
+Composing applications from isolated, reusable UI/Logic components.
+
+## Guidelines
+
+- `structure` - Atomic Design, State Management ([structure.md](structure.md))

package/data/architecture/component-based/structure.md

@@ -0,0 +1,63 @@
+# Component-Based Architecture
+
+## Core Principle
+
+Build the application as a composition of reusable, self-contained components. Common in frontend (React/Vue/Flutter) and mobile development.
+
+## Component Types
+
+### Atoms (Basic UI)
+
+Smallest units. Buttons, inputs, icons. No business logic.
+
+### Molecules (Composite)
+
+Groups of atoms. Search bar (Input + Button), User Card (Avatar + Text).
+
+### Organisms (Complex Sections)
+
+Complex standalone UI sections. Navigation bar, Product Grid.
+
+### Templates & Pages
+
+Layout structures and full views connecting organisms with data.
+
+## State Management
+
+- **Local State**: UI state specific to a component (e.g., `isOpen`).
+- **Lifted State**: Shared state moved up to a common ancestor.
+- **Global Store**: Application-wide state (Redux/Zustand/Bloc) for data accessed by many unrelated components.
+
+## Implementation Example (React)
+
+```tsx
+// Atom
+const Button = ({ onClick, children }) => (
+  <button onClick={onClick}>{children}</button>
+);
+
+// Molecule
+const SearchBar = ({ onSearch }) => (
+  <div className="search">
+    <Input />
+    <Button onClick={onSearch}>Search</Button>
+  </div>
+);
+
+// Page (Organism composition)
+const Dashboard = () => {
+  return (
+    <Layout>
+      <Header />
+      <SearchBar />
+      <UserGrid />
+    </Layout>
+  );
+};
+```
+
+## Best Practices
+
+- **Single Responsibility**: A component should do one thing well.
+- **Props Interface**: Define clear contracts for data input.
+- **Composition over Inheritance**: Build complex UIs by combining simpler components.

package/data/architecture/index.md

@@ -10,3 +10,5 @@ Architecture-specific guidelines and best practices.
 - `layered/` - Layered architecture
 - `hexagonal/` - Hexagonal (Ports & Adapters) architecture
 - `refactor/` - Refactoring strategies
+- `bounded-contexts/` - Bounded Contexts architecture
+- `component-based/` - Component-Based architecture

package/data/guideline-mappings.yml

@@ -1203,3 +1203,115 @@ patterns-gof:
     - observer
     - decorator
   category: Design Patterns
+architecture-bounded-contexts:
+  path: architecture/bounded-contexts/context-map.md
+  architectures:
+    - bounded-contexts
+  levels:
+    - standard
+    - expert
+    - full
+  tags:
+    - ddd
+    - boundaries
+    - context-mapping
+  category: Architecture
+
+architecture-component-based:
+  path: architecture/component-based/structure.md
+  architectures:
+    - component-based
+  levels:
+    - basic
+    - standard
+    - expert
+    - full
+  tags:
+    - components
+    - react
+    - ui
+    - composition
+  category: Architecture
+kotlin-basics:
+  path: language/kotlin/basics.md
+  languages:
+    - kotlin
+  levels:
+    - basic
+    - standard
+    - expert
+    - full
+  tags:
+    - kotlin
+    - null-safety
+    - basics
+  category: Language
+
+kotlin-coroutines:
+  path: language/kotlin/coroutines.md
+  languages:
+    - kotlin
+  levels:
+    - standard
+    - expert
+    - full
+  tags:
+    - kotlin
+    - async
+    - coroutines
+  category: Language
+
+kotlin-idioms:
+  path: language/kotlin/idioms.md
+  languages:
+    - kotlin
+  levels:
+    - expert
+    - full
+  tags:
+    - kotlin
+    - scope-functions
+    - extensions
+  category: Language
+
+php-basics:
+  path: language/php/basics.md
+  languages:
+    - php
+  levels:
+    - basic
+    - standard
+    - expert
+    - full
+  tags:
+    - php
+    - types
+    - basics
+  category: Language
+
+php-oop:
+  path: language/php/oop.md
+  languages:
+    - php
+  levels:
+    - standard
+    - expert
+    - full
+  tags:
+    - php
+    - oop
+    - interfaces
+  category: Language
+
+php-modern:
+  path: language/php/modern.md
+  languages:
+    - php
+  levels:
+    - expert
+    - full
+  tags:
+    - php
+    - php8
+    - attributes
+  category: Language

package/data/language/index.md

@@ -12,3 +12,6 @@ Programming language best practices and idioms.
 - `java/` - Java guidelines
 - `csharp/` - C# guidelines
 - `ruby/` - Ruby guidelines
+- `swift/` - Swift guidelines
+- `kotlin/` - Kotlin guidelines
+- `php/` - PHP guidelines

package/data/language/kotlin/basics.md

@@ -0,0 +1,35 @@
+# Kotlin Basics
+
+## Null Safety
+
+Kotlin distinguishes between nullable and non-nullable types.
+
+- `String` - Cannot hold null.
+- `String?` - Can hold null.
+
+```kotlin
+var a: String = "abc"
+// a = null // compilation error
+
+var b: String? = "abc"
+b = null // ok
+```
+
+Use safe calls (`?.`) or the Elvis operator (`?:`) when dealing with nullable types.
+
+```kotlin
+val l = b?.length ?: -1
+```
+
+## Val vs Var
+
+- `val`: Read-only (immutable reference). Prefer this by default.
+- `var`: Mutable.
+
+## Data Classes
+
+Use data classes to hold data. They automatically generate `equals()`, `hashCode()`, `toString()`, and `copy()`.
+
+```kotlin
+data class User(val name: String, val age: Int)
+```

package/data/language/kotlin/coroutines.md

@@ -0,0 +1,32 @@
+# Kotlin Coroutines
+
+## Suspend Functions
+
+Functions that can pause and resume execution without blocking the thread.
+
+```kotlin
+suspend fun fetchData(): String {
+    delay(1000) // Non-blocking delay
+    return "Data"
+}
+```
+
+## Builders
+
+- `launch`: Starts a new coroutine that does not return a result (fire and forget).
+- `async`: Starts a new coroutine that returns a `Deferred` (like a Promise).
+
+## Dispatchers
+
+- `Dispatchers.Main`: UI thread.
+- `Dispatchers.IO`: Network/Disk operations.
+- `Dispatchers.Default`: CPU-intensive work.
+
+```kotlin
+viewModelScope.launch(Dispatchers.IO) {
+    val data = fetchData()
+    withContext(Dispatchers.Main) {
+        updateUI(data)
+    }
+}
+```

package/data/language/kotlin/idioms.md

@@ -0,0 +1,48 @@
+# Kotlin Idioms
+
+## Scope Functions
+
+Functions that execute a block of code within the context of an object.
+
+### let
+
+Use for null checks or mapping.
+
+```kotlin
+val str: String? = "hello"
+str?.let {
+    println(it.length)
+}
+```
+
+### apply
+
+Use for object configuration. Returns the object itself.
+
+```kotlin
+val dialog = Dialog(context).apply {
+    setTitle("Hello")
+    show()
+}
+```
+
+### run
+
+Use for object configuration and computing a result.
+
+```kotlin
+val result = service.run {
+    configure()
+    execute()
+}
+```
+
+## Extension Functions
+
+Add functionality to existing classes without inheriting from them.
+
+```kotlin
+fun String.removeSpaces(): String = this.replace(" ", "")
+
+val clean = "hello world".removeSpaces()
+```

package/data/language/kotlin/index.md

@@ -0,0 +1,9 @@
+# Kotlin Guidelines
+
+Best practices for Kotlin development on Android and backend.
+
+## Guidelines
+
+- `basics` - Syntax, Null Safety, Data Classes ([basics.md](basics.md))
+- `coroutines` - Async programming, Suspended functions ([coroutines.md](coroutines.md))
+- `idioms` - Scope functions (`let`, `apply`), Extensions ([idioms.md](idioms.md))

package/data/language/php/basics.md

@@ -0,0 +1,39 @@
+# PHP Basics
+
+## Strict Types
+
+Always enable strict typing in new files to prevent unexpected type coercion.
+
+```php
+declare(strict_types=1);
+```
+
+## Type Declarations
+
+Always specify argument and return types.
+
+```php
+function add(int $a, int $b): int {
+    return $a + $b;
+}
+```
+
+## Union and Intersection Types
+
+Use robust type definitions.
+
+```php
+function process(Input|string $data): Result&Serializable {
+    // ...
+}
+```
+
+## Nullable Types
+
+Use `?Type` for nullable arguments or return values.
+
+```php
+function find(?int $id): ?User {
+    return $id ? User::find($id) : null;
+}
+```

package/data/language/php/index.md

@@ -0,0 +1,9 @@
+# PHP Guidelines
+
+Modern PHP standards and best practices (PHP 8.0+).
+
+## Guidelines
+
+- `basics` - Strict types, Type declarations ([basics.md](basics.md))
+- `oop` - Classes, Interfaces, Enums ([oop.md](oop.md))
+- `modern` - Attributes, Match expressions ([modern.md](modern.md))

package/data/language/php/modern.md

@@ -0,0 +1,36 @@
+# Modern PHP
+
+## Attributes
+
+Use Attributes (PHP 8+) instead of PHPDoc annotations.
+
+```php
+#[Route('/api/users', methods: ['GET'])]
+public function list(): Response { ... }
+```
+
+## Constructor Property Promotion
+
+Reduce boilerplate by defining properties in the constructor.
+
+```php
+class Point {
+    public function __construct(
+        public float $x = 0.0,
+        public float $y = 0.0,
+    ) {}
+}
+```
+
+## Match Expression
+
+Use `match` instead of `switch`. It is strict, returns a value, and doesn't fall through.
+
+```php
+$message = match ($statusCode) {
+    200, 300 => null,
+    400 => 'not found',
+    500 => 'server error',
+    default => 'unknown status code',
+};
+```

package/data/language/php/oop.md

@@ -0,0 +1,45 @@
+# PHP OOP
+
+## Classes and properties
+
+Use typed properties and visibility modifiers.
+
+```php
+class User {
+    public function __construct(
+        private string $name,
+        public readonly int $id
+    ) {}
+}
+```
+
+## Interfaces
+
+Define contracts using interfaces.
+
+```php
+interface Logger {
+    public function log(string $message): void;
+}
+```
+
+## Traits
+
+Use traits for horizontal code reuse, but use sparingly.
+
+```php
+trait Loggable {
+    private function log(string $msg) { ... }
+}
+```
+
+## Enums
+
+Use native Enums (PHP 8.1+) instead of class constants.
+
+```php
+enum Status: string {
+    case Draft = 'draft';
+    case Published = 'published';
+}
+```

package/data/version.json

@@ -1,10 +1,10 @@
 {
   "version": "1.0.0",
   "lastUpdated": "2026-01-15",
-  "totalGuidelines": 91,
+  "totalGuidelines": 99,
   "categories": {
-    "Language": 33,
-    "Architecture": 19,
+    "Language": 39,
+    "Architecture": 21,
     "Testing": 4,
     "Security": 4,
     "Performance": 4,
@@ -26,7 +26,9 @@
     "ruby": 2,
     "javascript": 2,
     "dart": 4,
-    "swift": 5
+    "swift": 5,
+    "kotlin": 3,
+    "php": 3
   },
   "architectures": {
     "microservices": 5,
@@ -36,13 +38,15 @@
     "event-driven": 2,
     "layered": 1,
     "serverless": 2,
-    "hexagonal": 1
+    "hexagonal": 1,
+    "bounded-contexts": 1,
+    "component-based": 1
   },
   "levels": {
-    "basic": 20,
-    "standard": 77,
-    "expert": 91,
-    "full": 91
+    "basic": 23,
+    "standard": 83,
+    "expert": 99,
+    "full": 99
   },
   "datasources": {
     "sql": 3,

package/dist/index.js

@@ -48492,6 +48492,144 @@ var EMBEDDED_DATA = {
         "decorator"
       ],
       category: "Design Patterns"
+    },
+    "architecture-bounded-contexts": {
+      path: "architecture/bounded-contexts/context-map.md",
+      architectures: [
+        "bounded-contexts"
+      ],
+      levels: [
+        "standard",
+        "expert",
+        "full"
+      ],
+      tags: [
+        "ddd",
+        "boundaries",
+        "context-mapping"
+      ],
+      category: "Architecture"
+    },
+    "architecture-component-based": {
+      path: "architecture/component-based/structure.md",
+      architectures: [
+        "component-based"
+      ],
+      levels: [
+        "basic",
+        "standard",
+        "expert",
+        "full"
+      ],
+      tags: [
+        "components",
+        "react",
+        "ui",
+        "composition"
+      ],
+      category: "Architecture"
+    },
+    "kotlin-basics": {
+      path: "language/kotlin/basics.md",
+      languages: [
+        "kotlin"
+      ],
+      levels: [
+        "basic",
+        "standard",
+        "expert",
+        "full"
+      ],
+      tags: [
+        "kotlin",
+        "null-safety",
+        "basics"
+      ],
+      category: "Language"
+    },
+    "kotlin-coroutines": {
+      path: "language/kotlin/coroutines.md",
+      languages: [
+        "kotlin"
+      ],
+      levels: [
+        "standard",
+        "expert",
+        "full"
+      ],
+      tags: [
+        "kotlin",
+        "async",
+        "coroutines"
+      ],
+      category: "Language"
+    },
+    "kotlin-idioms": {
+      path: "language/kotlin/idioms.md",
+      languages: [
+        "kotlin"
+      ],
+      levels: [
+        "expert",
+        "full"
+      ],
+      tags: [
+        "kotlin",
+        "scope-functions",
+        "extensions"
+      ],
+      category: "Language"
+    },
+    "php-basics": {
+      path: "language/php/basics.md",
+      languages: [
+        "php"
+      ],
+      levels: [
+        "basic",
+        "standard",
+        "expert",
+        "full"
+      ],
+      tags: [
+        "php",
+        "types",
+        "basics"
+      ],
+      category: "Language"
+    },
+    "php-oop": {
+      path: "language/php/oop.md",
+      languages: [
+        "php"
+      ],
+      levels: [
+        "standard",
+        "expert",
+        "full"
+      ],
+      tags: [
+        "php",
+        "oop",
+        "interfaces"
+      ],
+      category: "Language"
+    },
+    "php-modern": {
+      path: "language/php/modern.md",
+      languages: [
+        "php"
+      ],
+      levels: [
+        "expert",
+        "full"
+      ],
+      tags: [
+        "php",
+        "php8",
+        "attributes"
+      ],
+      category: "Language"
     }
   },
   guidelines: {
@@ -50461,6 +50599,139 @@ let (result1, result2) = tokio::join!(
     fetch_data("url2")
 );
 \`\`\`
+`,
+    "language/php/modern.md": `# Modern PHP
+
+## Attributes
+
+Use Attributes (PHP 8+) instead of PHPDoc annotations.
+
+\`\`\`php
+#[Route('/api/users', methods: ['GET'])]
+public function list(): Response { ... }
+\`\`\`
+
+## Constructor Property Promotion
+
+Reduce boilerplate by defining properties in the constructor.
+
+\`\`\`php
+class Point {
+    public function __construct(
+        public float $x = 0.0,
+        public float $y = 0.0,
+    ) {}
+}
+\`\`\`
+
+## Match Expression
+
+Use \`match\` instead of \`switch\`. It is strict, returns a value, and doesn't fall through.
+
+\`\`\`php
+$message = match ($statusCode) {
+    200, 300 => null,
+    400 => 'not found',
+    500 => 'server error',
+    default => 'unknown status code',
+};
+\`\`\`
+`,
+    "language/php/oop.md": `# PHP OOP
+
+## Classes and properties
+
+Use typed properties and visibility modifiers.
+
+\`\`\`php
+class User {
+    public function __construct(
+        private string $name,
+        public readonly int $id
+    ) {}
+}
+\`\`\`
+
+## Interfaces
+
+Define contracts using interfaces.
+
+\`\`\`php
+interface Logger {
+    public function log(string $message): void;
+}
+\`\`\`
+
+## Traits
+
+Use traits for horizontal code reuse, but use sparingly.
+
+\`\`\`php
+trait Loggable {
+    private function log(string $msg) { ... }
+}
+\`\`\`
+
+## Enums
+
+Use native Enums (PHP 8.1+) instead of class constants.
+
+\`\`\`php
+enum Status: string {
+    case Draft = 'draft';
+    case Published = 'published';
+}
+\`\`\`
+`,
+    "language/php/basics.md": `# PHP Basics
+
+## Strict Types
+
+Always enable strict typing in new files to prevent unexpected type coercion.
+
+\`\`\`php
+declare(strict_types=1);
+\`\`\`
+
+## Type Declarations
+
+Always specify argument and return types.
+
+\`\`\`php
+function add(int $a, int $b): int {
+    return $a + $b;
+}
+\`\`\`
+
+## Union and Intersection Types
+
+Use robust type definitions.
+
+\`\`\`php
+function process(Input|string $data): Result&Serializable {
+    // ...
+}
+\`\`\`
+
+## Nullable Types
+
+Use \`?Type\` for nullable arguments or return values.
+
+\`\`\`php
+function find(?int $id): ?User {
+    return $id ? User::find($id) : null;
+}
+\`\`\`
+`,
+    "language/php/index.md": `# PHP Guidelines
+
+Modern PHP standards and best practices (PHP 8.0+).
+
+## Guidelines
+
+- \`basics\` - Strict types, Type declarations ([basics.md](basics.md))
+- \`oop\` - Classes, Interfaces, Enums ([oop.md](oop.md))
+- \`modern\` - Attributes, Match expressions ([modern.md](modern.md))
 `,
     "language/java/testing.md": `# Java Testing (JUnit 5)
 
@@ -54239,6 +54510,90 @@ struct User {
 - [Google Swift Style Guide](https://google.github.io/swift/)
 - [Kodeco Swift Style Guide](https://github.com/kodecocodes/swift-style-guide)
 `,
+    "language/kotlin/coroutines.md": `# Kotlin Coroutines
+
+## Suspend Functions
+
+Functions that can pause and resume execution without blocking the thread.
+
+\`\`\`kotlin
+suspend fun fetchData(): String {
+    delay(1000) // Non-blocking delay
+    return "Data"
+}
+\`\`\`
+
+## Builders
+
+- \`launch\`: Starts a new coroutine that does not return a result (fire and forget).
+- \`async\`: Starts a new coroutine that returns a \`Deferred\` (like a Promise).
+
+## Dispatchers
+
+- \`Dispatchers.Main\`: UI thread.
+- \`Dispatchers.IO\`: Network/Disk operations.
+- \`Dispatchers.Default\`: CPU-intensive work.
+
+\`\`\`kotlin
+viewModelScope.launch(Dispatchers.IO) {
+    val data = fetchData()
+    withContext(Dispatchers.Main) {
+        updateUI(data)
+    }
+}
+\`\`\`
+`,
+    "language/kotlin/idioms.md": `# Kotlin Idioms
+
+## Scope Functions
+
+Functions that execute a block of code within the context of an object.
+
+### let
+
+Use for null checks or mapping.
+
+\`\`\`kotlin
+val str: String? = "hello"
+str?.let {
+    println(it.length)
+}
+\`\`\`
+
+### apply
+
+Use for object configuration. Returns the object itself.
+
+\`\`\`kotlin
+val dialog = Dialog(context).apply {
+    setTitle("Hello")
+    show()
+}
+\`\`\`
+
+### run
+
+Use for object configuration and computing a result.
+
+\`\`\`kotlin
+val result = service.run {
+    configure()
+    execute()
+}
+\`\`\`
+
+## Extension Functions
+
+Add functionality to existing classes without inheriting from them.
+
+\`\`\`kotlin
+fun String.removeSpaces(): String = this.replace(" ", "")
+
+val clean = "hello world".removeSpaces()
+\`\`\`
+`,
+    "language/kotlin/basics.md": '# Kotlin Basics\n\n## Null Safety\n\nKotlin distinguishes between nullable and non-nullable types.\n\n- `String` - Cannot hold null.\n- `String?` - Can hold null.\n\n```kotlin\nvar a: String = "abc"\n// a = null // compilation error\n\nvar b: String? = "abc"\nb = null // ok\n```\n\nUse safe calls (`?.`) or the Elvis operator (`?:`) when dealing with nullable types.\n\n```kotlin\nval l = b?.length ?: -1\n```\n\n## Val vs Var\n\n- `val`: Read-only (immutable reference). Prefer this by default.\n- `var`: Mutable.\n\n## Data Classes\n\nUse data classes to hold data. They automatically generate `equals()`, `hashCode()`, `toString()`, and `copy()`.\n\n```kotlin\ndata class User(val name: String, val age: Int)\n```\n',
+    "language/kotlin/index.md": "# Kotlin Guidelines\n\nBest practices for Kotlin development on Android and backend.\n\n## Guidelines\n\n- `basics` - Syntax, Null Safety, Data Classes ([basics.md](basics.md))\n- `coroutines` - Async programming, Suspended functions ([coroutines.md](coroutines.md))\n- `idioms` - Scope functions (`let`, `apply`), Extensions ([idioms.md](idioms.md))\n",
     "language/typescript/generics.md": `# TypeScript Generics
 
 ## Basic Generic Functions
@@ -57603,7 +57958,7 @@ stream.listen(
 - Use \`async*\` and \`yield\` for generating stream data
 - Prefer \`await for\` over \`listen\` for sequential processing
 `,
-    "language/index.md": "# Language-Specific Guidelines\n\nProgramming language best practices and idioms.\n\n## Available Languages\n\n- `typescript/` - TypeScript guidelines\n- `javascript/` - JavaScript (ES6+) guidelines\n- `python/` - Python guidelines\n- `go/` - Go guidelines\n- `rust/` - Rust guidelines\n- `java/` - Java guidelines\n- `csharp/` - C# guidelines\n- `ruby/` - Ruby guidelines\n",
+    "language/index.md": "# Language-Specific Guidelines\n\nProgramming language best practices and idioms.\n\n## Available Languages\n\n- `typescript/` - TypeScript guidelines\n- `javascript/` - JavaScript (ES6+) guidelines\n- `python/` - Python guidelines\n- `go/` - Go guidelines\n- `rust/` - Rust guidelines\n- `java/` - Java guidelines\n- `csharp/` - C# guidelines\n- `ruby/` - Ruby guidelines\n- `swift/` - Swift guidelines\n- `kotlin/` - Kotlin guidelines\n- `php/` - PHP guidelines\n",
     "patterns/domain-logic.md": `# Domain Logic Patterns
 
 ## Transaction Script
@@ -60216,6 +60571,78 @@ This directory contains feature toggle patterns.
 ## Available Chunks
 
 - **patterns.md** - Release toggles, experiment toggles, ops toggles
+`,
+    "architecture/component-based/structure.md": `# Component-Based Architecture
+
+## Core Principle
+
+Build the application as a composition of reusable, self-contained components. Common in frontend (React/Vue/Flutter) and mobile development.
+
+## Component Types
+
+### Atoms (Basic UI)
+
+Smallest units. Buttons, inputs, icons. No business logic.
+
+### Molecules (Composite)
+
+Groups of atoms. Search bar (Input + Button), User Card (Avatar + Text).
+
+### Organisms (Complex Sections)
+
+Complex standalone UI sections. Navigation bar, Product Grid.
+
+### Templates & Pages
+
+Layout structures and full views connecting organisms with data.
+
+## State Management
+
+- **Local State**: UI state specific to a component (e.g., \`isOpen\`).
+- **Lifted State**: Shared state moved up to a common ancestor.
+- **Global Store**: Application-wide state (Redux/Zustand/Bloc) for data accessed by many unrelated components.
+
+## Implementation Example (React)
+
+\`\`\`tsx
+// Atom
+const Button = ({ onClick, children }) => (
+  <button onClick={onClick}>{children}</button>
+);
+
+// Molecule
+const SearchBar = ({ onSearch }) => (
+  <div className="search">
+    <Input />
+    <Button onClick={onSearch}>Search</Button>
+  </div>
+);
+
+// Page (Organism composition)
+const Dashboard = () => {
+  return (
+    <Layout>
+      <Header />
+      <SearchBar />
+      <UserGrid />
+    </Layout>
+  );
+};
+\`\`\`
+
+## Best Practices
+
+- **Single Responsibility**: A component should do one thing well.
+- **Props Interface**: Define clear contracts for data input.
+- **Composition over Inheritance**: Build complex UIs by combining simpler components.
+`,
+    "architecture/component-based/index.md": `# Component-Based Architecture
+
+Composing applications from isolated, reusable UI/Logic components.
+
+## Guidelines
+
+- \`structure\` - Atomic Design, State Management ([structure.md](structure.md))
 `,
     "architecture/ddd/tactical.md": `# DDD Tactical Patterns
 
@@ -60557,6 +60984,65 @@ This directory contains layered architecture patterns.
 ## Available Chunks
 
 - **layers.md** - Presentation, Domain, Data Access layers
+`,
+    "architecture/bounded-contexts/context-map.md": `# Bounded Contexts
+
+## Core Principle
+
+Divide the domain into logical boundaries where a specific model applies. Each context has its own ubiquitous language, data model, and rules.
+
+## Context Mapping Patterns
+
+Relates different bounded contexts to each other.
+
+### Partnership
+
+Two contexts succeed or fail together. Teams work closely to align interfaces.
+
+### Shared Kernel
+
+Sharing a subset of the domain model (code/database) between contexts. High coupling, use sparingly (e.g., for generic Auth/IDs).
+
+### Customer/Supplier
+
+Downstream context (Customer) depends on Upstream context (Supplier). Upstream must negotiate changes with Downstream.
+
+### Conformist
+
+Downstream blindly conforms to Upstream's model without negotiation.
+
+### Anticorruption Layer (ACL)
+
+Downstream isolates itself from Upstream's model by translating it into its own internal model.
+
+## Implementation Structure
+
+\`\`\`typescript
+// Context: Sales
+namespace Sales {
+  export class Order { ... } // Sales-specific Order model
+}
+
+// Context: Shipping
+namespace Shipping {
+  export class Shipment { ... }
+  // Shipping might interact with Sales via ACL or events
+}
+\`\`\`
+
+## Best Practices
+
+- **Explicit Boundaries**: Code for one context should not bleed into another.
+- **Ubiquitous Language**: Use the same terminology in code as functionality.
+- **Decoupled Deployment**: Ideally, contexts can be deployed independently (microservices or modular monoliths).
+`,
+    "architecture/bounded-contexts/index.md": `# Bounded Contexts
+
+Domain-Driven Design (DDD) patterns for defining explicit model boundaries.
+
+## Guidelines
+
+- \`context-map\` - Context Mapping patterns (Partnership, Shared Kernel, ACL) ([context-map.md](context-map.md))
 `,
     "architecture/gui/patterns.md": `# GUI Architecture Patterns
 
@@ -60699,7 +61185,7 @@ This directory contains GUI architecture patterns.
 
 - **patterns.md** - MVC, MVP, MVVM, Component Architecture
 `,
-    "architecture/index.md": "# Architecture Patterns\n\nArchitecture-specific guidelines and best practices.\n\n## Available Architectures\n\n- `microservices/` - Microservices architecture\n- `modular-monolith/` - Modular monolith patterns\n- `event-driven/` - Event-driven architecture\n- `layered/` - Layered architecture\n- `hexagonal/` - Hexagonal (Ports & Adapters) architecture\n- `refactor/` - Refactoring strategies\n",
+    "architecture/index.md": "# Architecture Patterns\n\nArchitecture-specific guidelines and best practices.\n\n## Available Architectures\n\n- `microservices/` - Microservices architecture\n- `modular-monolith/` - Modular monolith patterns\n- `event-driven/` - Event-driven architecture\n- `layered/` - Layered architecture\n- `hexagonal/` - Hexagonal (Ports & Adapters) architecture\n- `refactor/` - Refactoring strategies\n- `bounded-contexts/` - Bounded Contexts architecture\n- `component-based/` - Component-Based architecture\n",
     "devops/ci-cd.md": `# CI/CD Practices
 
 ## Continuous Integration
@@ -67768,6 +68254,9 @@ class AnalysisValidator {
       "csharp",
       "ruby",
       "dart",
+      "swift",
+      "kotlin",
+      "php",
       "unknown"
     ]);
     this.validProjectTypes = new Set([
@@ -67789,6 +68278,8 @@ class AnalysisValidator {
       "ddd",
       "serverless",
       "monorepo",
+      "bounded-contexts",
+      "component-based",
       "other"
     ]);
     this.validDatasources = new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicgen/aicgen",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "AI Config Generator - Automated AI assistant configuration for your projects",
   "keywords": [
     "ai",