@aicgen/aicgen 1.0.4 → 1.1.0

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,
+  "lastUpdated": "2026-05-14",
+  "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/data/workflows/README.md

@@ -0,0 +1,51 @@
+# SDLC Workflows
+
+aicgen injects a structured 6-command SDLC workflow into every generated assistant configuration. These commands guide the AI assistant through a repeatable, artifact-driven development lifecycle.
+
+## The Flow
+
+```
+/spec → /research → /plan → /build → /check → /ship
+```
+
+| Step | Command | Output artifact |
+|------|---------|----------------|
+| 1 | [`/spec [name]`](sdlc/spec.md) | `docs/specs/{name}.md` |
+| 2 | [`/research`](sdlc/research.md) | Appends `## Research Findings` to spec |
+| 3 | [`/plan`](sdlc/plan.md) | `docs/plans/{name}.md` |
+| 4 | [`/build [phase?]`](sdlc/build.md) | Code changes |
+| 5 | [`/check`](sdlc/check.md) | Inline verification report |
+| 6 | [`/ship`](sdlc/ship.md) | PR description draft |
+
+## Commands
+
+- [/spec](sdlc/spec.md) — Capture feature requirements before writing any code
+- [/research](sdlc/research.md) — Codebase scan + web research + infrastructure preference
+- [/plan](sdlc/plan.md) — Phased, checkpoint-driven implementation plan
+- [/build](sdlc/build.md) — Execute plan phase by phase with review checkpoints
+- [/check](sdlc/check.md) — Verify implementation against spec and run tests
+- [/ship](sdlc/ship.md) — Pre-flight checks and PR description draft
+
+## Output directory
+
+All spec and plan artifacts are saved to the `docs/` directory in the user's project. This directory is created automatically if it does not exist.
+
+```
+docs/
+├── specs/
+│   └── {feature-name}.md
+└── plans/
+    └── {feature-name}.md
+```
+
+## Guard rails
+
+| Command | Pre-condition |
+|---------|--------------|
+| `/research` | Active spec in `docs/specs/` — prompts `/spec` if missing |
+| `/plan` | Active spec with `## Research Findings` — warns if research was skipped |
+| `/build` | Active plan in `docs/plans/` — prompts `/plan` if missing |
+
+## Source
+
+Command definitions are maintained in [`aicgen/data/workflows/sdlc.md`](https://github.com/aicgen/aicgen/blob/main/data/workflows/sdlc.md) and injected into every generated config at `aicgen init` time.

package/data/workflows/sdlc/build.md

@@ -0,0 +1,38 @@
+# /build [phase]
+
+**Purpose:** Execute the next (or a specified) phase of the current implementation plan, pausing between phases for review.
+
+## When to use
+
+After `/plan`. Run once per phase until all phases are complete. Can also be used to re-execute a specific phase by passing its number.
+
+## Arguments
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| `phase` | No | Phase number to execute. If omitted, executes the next incomplete phase. |
+
+## Pre-condition
+
+An active plan must exist in `docs/plans/`. If none is found, the assistant will prompt you to run `/plan` first and stop.
+
+## Steps
+
+1. Read the active plan from `docs/plans/`
+2. Determine the next incomplete phase (or the specified phase)
+3. Announce which phase is being executed and what it covers
+4. Implement step by step, following existing codebase patterns and conventions
+5. Summarise what was changed and created
+6. Mark the phase complete in the plan file
+7. Run relevant tests and report results
+8. Ask: "Phase {n} complete. Continue to phase {n+1}?" before proceeding
+
+## Behaviour
+
+- The assistant pauses after each phase and waits for your go-ahead
+- If tests fail at the end of a phase, the assistant reports failures before asking to continue
+- The plan file is updated in place as phases are completed — it acts as a progress tracker
+
+## Next step
+
+After all phases are complete, run [`/check`](check.md) to verify the full implementation against the spec.