project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/core-concepts/standards.mdx

@@ -0,0 +1,277 @@
+---
+title: Standards
+description: Project decisions that inform AI code generation
+---
+
+## What are Standards?
+
+**Standards** are project decisions that inform AI code generation. They ensure consistency across all generated code and documentation.
+
+<Info>
+  Standards are established during project initialization and guide every agent interaction. They're the "rules of the road" for your project.
+</Info>
+
+## Standard Types
+
+<CardGroup cols={2}>
+  <Card title="Tech Stack" icon="layer-group">
+    Languages, frameworks, databases, infrastructure
+  </Card>
+  <Card title="Coding Standards" icon="code">
+    Formatting, linting, naming, testing strategy
+  </Card>
+  <Card title="Architecture" icon="sitemap">
+    Architecture style, API design, state management
+  </Card>
+  <Card title="UX Guide" icon="palette">
+    Design system, styling, accessibility
+  </Card>
+</CardGroup>
+
+## Establishing Standards
+
+During project initialization:
+
+```bash
+/specsmd-master-agent
+> project-init
+```
+
+The Master Agent guides you through each standard category with facilitation guides.
+
+## Tech Stack Standard
+
+Defines your technology choices:
+
+```markdown
+# Tech Stack
+
+## Languages
+- **Primary**: TypeScript 5.x
+- **Secondary**: Python 3.11+ (for ML pipelines)
+
+## Frontend
+- **Framework**: React 18 with Next.js 14
+- **Styling**: Tailwind CSS
+- **State**: Zustand
+
+## Backend
+- **Runtime**: Node.js 20 LTS
+- **Framework**: Express.js
+- **ORM**: Prisma
+
+## Database
+- **Primary**: PostgreSQL 15
+- **Cache**: Redis 7
+- **Search**: Elasticsearch 8
+
+## Infrastructure
+- **Cloud**: AWS
+- **Containers**: Docker
+- **Orchestration**: ECS Fargate
+- **CI/CD**: GitHub Actions
+```
+
+## Coding Standards
+
+Defines how code should be written:
+
+```markdown
+# Coding Standards
+
+## Formatting
+- Use Prettier with default config
+- 2-space indentation
+- Single quotes for strings
+- Trailing commas in multiline
+
+## Naming Conventions
+- **Files**: kebab-case (user-service.ts)
+- **Classes**: PascalCase (UserService)
+- **Functions**: camelCase (getUserById)
+- **Constants**: SCREAMING_SNAKE_CASE (MAX_RETRIES)
+
+## Testing Strategy
+- **Unit Tests**: Vitest for business logic
+- **Integration Tests**: Supertest for APIs
+- **E2E Tests**: Playwright for critical paths
+- **Coverage Target**: 80% minimum
+
+## Error Handling
+- Use custom error classes extending BaseError
+- Always include error codes
+- Log errors with structured logging
+- Never expose internal errors to clients
+```
+
+## Architecture Standard
+
+Defines system design decisions:
+
+```markdown
+# Architecture
+
+## Style
+- **Pattern**: Clean Architecture
+- **API**: REST with OpenAPI 3.0
+- **Communication**: Synchronous HTTP, async via SQS
+
+## Layers
+1. **Presentation**: Controllers, DTOs
+2. **Application**: Use cases, services
+3. **Domain**: Entities, value objects, events
+4. **Infrastructure**: Repositories, external services
+
+## API Design
+- Resource-based URLs
+- HTTP methods for actions
+- JSON request/response bodies
+- Pagination with cursor-based approach
+
+## State Management
+- Server state: React Query
+- Client state: Zustand
+- Form state: React Hook Form
+```
+
+## UX Guide (Optional)
+
+Defines design system and styling:
+
+```markdown
+# UX Guide
+
+## Design System
+- Based on custom design tokens
+- Component library: shadcn/ui
+
+## Colors
+- Primary: #2563eb
+- Secondary: #64748b
+- Success: #10b981
+- Error: #ef4444
+
+## Typography
+- Headings: Inter, sans-serif
+- Body: Inter, sans-serif
+- Mono: JetBrains Mono
+
+## Spacing
+- Base unit: 4px
+- Scale: 4, 8, 12, 16, 24, 32, 48, 64
+
+## Accessibility
+- WCAG 2.1 AA compliance
+- Keyboard navigation required
+- Screen reader support
+- Color contrast 4.5:1 minimum
+```
+
+## How Standards Are Used
+
+Agents reference standards when generating code:
+
+<Steps>
+  <Step title="Context Loading">
+    Agent reads all standards from Memory Bank
+  </Step>
+  <Step title="Decision Making">
+    Standards inform architecture and design choices
+  </Step>
+  <Step title="Code Generation">
+    Generated code follows coding standards
+  </Step>
+  <Step title="Validation">
+    Output is checked against standards
+  </Step>
+</Steps>
+
+## Updating Standards
+
+Standards can evolve. To update:
+
+1. Edit the relevant file in `memory-bank/standards/`
+2. Commit the change with clear rationale
+3. Consider an ADR for significant changes
+4. Inform the team
+
+<Warning>
+  Changing standards affects all future code generation. Major changes should be documented in an ADR and reviewed by the team.
+</Warning>
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Be Specific">
+    Vague standards lead to inconsistent code. "Use good naming" is useless. "Use camelCase for functions" is clear.
+  </Accordion>
+  <Accordion title="Document Rationale">
+    Explain why, not just what. Future team members will thank you.
+  </Accordion>
+  <Accordion title="Keep Current">
+    Update standards when the team adopts new practices. Outdated standards are ignored.
+  </Accordion>
+  <Accordion title="Start Simple">
+    You don't need every detail on day one. Add specifics as patterns emerge.
+  </Accordion>
+</AccordionGroup>
+
+## Standards Catalog
+
+Standards are defined in `.specsmd/aidlc/templates/standards/catalog.yaml`. This catalog controls:
+
+- Which standards exist and their importance
+- Decisions within each standard
+- Dependencies between standards
+- Project type presets
+
+```yaml
+standards:
+  tech-stack:
+    description: Core technology choices
+    facilitation: templates/standards/tech-stack.guide.md
+    importance: critical
+    decisions:
+      - id: languages
+        display_name: Languages
+        importance: critical
+      - id: framework
+        display_name: Framework
+        depends_on: [languages]
+      # ...
+
+  coding-standards:
+    depends_on_standards: [tech-stack]
+    decisions:
+      - id: formatting
+      - id: testing_strategy
+      # ...
+
+project_types:
+  full-stack-web:
+    required_standards: [tech-stack, data-stack, coding-standards]
+    recommended_standards: [system-architecture, ux-guide]
+```
+
+### Extensibility
+
+The catalog is designed for extensibility:
+
+<CardGroup cols={2}>
+  <Card title="Add New Standards" icon="plus">
+    Add entries to `standards:` with facilitation guides
+  </Card>
+  <Card title="Custom Decisions" icon="sliders">
+    Add decisions to existing standards
+  </Card>
+  <Card title="Project Types" icon="folder-tree">
+    Define custom project type presets
+  </Card>
+  <Card title="Dependencies" icon="link">
+    Control order via `depends_on_standards`
+  </Card>
+</CardGroup>
+
+<Info>
+  Each standard has a facilitation guide (`.guide.md`) that defines the questions asked during `project-init`. Customize these to match your team's decision-making process.
+</Info>

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/core-concepts/units.mdx

@@ -0,0 +1,184 @@
+---
+title: Units
+description: Cohesive, self-contained work elements derived from Intents
+---
+
+## What is a Unit?
+
+A **Unit** is a cohesive, self-contained work element derived from an Intent. Units are loosely coupled and can be developed independently.
+
+<Info>
+  A Unit is analogous to a **Subdomain** in DDD or an **Epic** in Scrum, but with clearer boundaries and AI-assisted decomposition.
+</Info>
+
+## Unit Characteristics
+
+<CardGroup cols={2}>
+  <Card title="Cohesive" icon="object-group">
+    All elements within a unit serve a single, focused purpose
+  </Card>
+  <Card title="Self-Contained" icon="box">
+    Can be developed and tested independently
+  </Card>
+  <Card title="Loosely Coupled" icon="link-slash">
+    Minimal dependencies on other units
+  </Card>
+  <Card title="Well-Bounded" icon="border-all">
+    Clear interfaces with the rest of the system
+  </Card>
+</CardGroup>
+
+## Example: Authentication Intent → Units
+
+An "User Authentication System" intent might decompose into:
+
+```
+Intent: User Authentication System
+├── Unit: User Registration
+│   ├── Registration form
+│   ├── Email validation
+│   └── Account creation
+├── Unit: User Login
+│   ├── Login form
+│   ├── Session management
+│   └── Remember me
+├── Unit: Password Management
+│   ├── Password reset
+│   ├── Password change
+│   └── Password policies
+└── Unit: Session Management
+    ├── Token handling
+    ├── Session expiry
+    └── Logout
+```
+
+## Unit Structure
+
+Each unit lives in its own directory:
+
+```
+memory-bank/intents/{intent}/units/{unit-name}/
+├── unit-brief.md        # Unit definition and scope
+├── stories/             # User stories for this unit
+│   ├── story-001.md
+│   └── story-002.md
+└── bolts/               # Bolt execution records
+    ├── bolt-001/
+    └── bolt-002/
+```
+
+## Unit Brief
+
+The `unit-brief.md` defines the unit:
+
+```markdown
+# Unit: User Registration
+
+## Purpose
+Enable new users to create accounts in the system.
+
+## Scope
+
+### In Scope
+- Email/password registration
+- Email validation
+- Account creation in database
+- Welcome email
+
+### Out of Scope
+- Social login (separate unit)
+- Profile management (separate unit)
+
+## Dependencies
+- Email Service (external)
+- User Database (shared)
+
+## Interfaces
+
+### Inputs
+- Registration form data (email, password)
+
+### Outputs
+- User account created
+- Confirmation email sent
+
+## Stories
+- US-001: User Registration Form
+- US-002: Email Validation
+- US-003: Welcome Email
+```
+
+## Decomposing into Units
+
+The Inception Agent helps decompose intents:
+
+```bash
+/specsmd-inception-agent units
+```
+
+The agent will:
+
+<Steps>
+  <Step title="Analyze Requirements">
+    Review user stories and NFRs from the intent
+  </Step>
+  <Step title="Identify Boundaries">
+    Find natural groupings based on cohesion
+  </Step>
+  <Step title="Propose Units">
+    Suggest unit structure with rationale
+  </Step>
+  <Step title="Define Interfaces">
+    Establish how units communicate
+  </Step>
+  <Step title="Map Dependencies">
+    Identify unit interdependencies
+  </Step>
+</Steps>
+
+## Unit Dependencies
+
+Units should be loosely coupled, but some dependencies are natural:
+
+```mermaid
+flowchart TB
+    REG[Registration] -->|creates| SESSION[Session Mgmt]
+    LOGIN[Login] --> SESSION
+    PWD[Password Mgmt] -->|uses| SESSION
+
+    style REG fill:#818CF8,stroke:#6366F1,color:#fff
+    style LOGIN fill:#34D399,stroke:#10B981,color:#fff
+    style SESSION fill:#8B5CF6,stroke:#7C3AED,color:#fff
+    style PWD fill:#FBBF24,stroke:#F59E0B,color:#fff
+```
+
+<Warning>
+  Circular dependencies between units indicate poor decomposition. If Unit A depends on Unit B and Unit B depends on Unit A, consider merging them or extracting the shared concern.
+</Warning>
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Single Responsibility">
+    Each unit should have one clear purpose. If a unit is doing too many things, split it.
+  </Accordion>
+  <Accordion title="Clear Boundaries">
+    Define explicit interfaces. Other units should only interact through these interfaces.
+  </Accordion>
+  <Accordion title="Independent Development">
+    You should be able to work on a unit without constantly coordinating with other units.
+  </Accordion>
+  <Accordion title="Testable in Isolation">
+    A unit should be testable without requiring the full system.
+  </Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+<Card
+  title="Bolts"
+  icon="arrow-right"
+  href="/core-concepts/bolts"
+>
+  Learn how Units are implemented through Bolts
+</Card>

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/docs.json

@@ -0,0 +1,148 @@
+{
+  "$schema": "https://mintlify.com/docs.json",
+  "theme": "mint",
+  "name": "iris.md",
+  "description": "AI-native software development with multi-agent orchestration. Implement AI-DLC methodology with markdown-based agents for Claude Code, Cursor, and GitHub Copilot.",
+  "metadata": {
+    "og:site_name": "iris.md",
+    "og:type": "website",
+    "og:image": "/images/logo.png",
+    "og:locale": "en_US",
+    "twitter:card": "summary_large_image",
+    "twitter:site": "@irismd",
+    "twitter:image": "/images/logo.png",
+    "keywords": "AI-DLC, AI-native development, software development lifecycle, multi-agent orchestration, Claude Code, Cursor, GitHub Copilot, Domain-Driven Design, spec-driven development"
+  },
+  "seo": {
+    "indexHiddenPages": true
+  },
+  "logo": {
+    "dark": "/images/logo.png",
+    "light": "/images/logo.png"
+  },
+  "favicon": "/images/favicon.png",
+  "colors": {
+    "primary": "#CD6B4D",
+    "light": "#D17A5E",
+    "dark": "#B85A3D"
+  },
+  "navbar": {
+    "links": [
+      {
+        "label": "github",
+        "href": "https://github.com/fabriqaai/iris.md"
+      },
+      {
+        "label": "npm",
+        "href": "https://www.npmjs.com/package/irismd"
+      },
+      {
+        "label": "vscode extension",
+        "href": "https://marketplace.visualstudio.com/items?itemName=fabriqaai.irismd"
+      },
+      {
+        "label": "product hunt",
+        "href": "https://www.producthunt.com/products/iris-md"
+      }
+    ],
+    "primary": {
+      "type": "button",
+      "label": "Get Started",
+      "href": "/getting-started/installation"
+    }
+  },
+  "navigation": {
+    "tabs": [
+      {
+        "tab": "Documentation",
+        "groups": [
+          {
+            "group": "Getting Started",
+            "pages": [
+              "index",
+              "getting-started/installation",
+              "getting-started/vscode-extension",
+              "getting-started/quick-start"
+            ]
+          },
+          {
+            "group": "Why iris.md",
+            "pages": [
+              "methodology/sdlc-reimagined",
+              "methodology/what-is-ai-dlc",
+              "methodology/ai-dlc-vs-agile",
+              "methodology/three-phases"
+            ]
+          },
+          {
+            "group": "Framework",
+            "pages": [
+              "architecture/flows"
+            ]
+          },
+          {
+            "group": "AI-DLC Flow",
+            "pages": [
+              {
+                "group": "Concepts",
+                "pages": [
+                  "core-concepts/intents",
+                  "core-concepts/units",
+                  "core-concepts/bolts",
+                  "core-concepts/memory-bank",
+                  "core-concepts/standards"
+                ]
+              },
+              {
+                "group": "Agents",
+                "pages": [
+                  "agents/overview",
+                  "agents/master-agent",
+                  "agents/inception-agent",
+                  "agents/construction-agent",
+                  "agents/operations-agent"
+                ]
+              },
+              {
+                "group": "Guides",
+                "pages": [
+                  "guides/bolt-types"
+                ]
+              }
+            ]
+          },
+          {
+            "group": "Compare",
+            "pages": [
+              "compare/overview",
+              "compare/vs-speckit",
+              "compare/vs-bmad",
+              "compare/vs-kiro",
+              "compare/vs-openspec"
+            ]
+          },
+          {
+            "group": "Resources",
+            "pages": [
+              "faq",
+              "feedback",
+              "community"
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  "footer": {
+    "socials": {
+      "github": "https://github.com/fabriqaai/iris.md",
+      "discord": "https://discord.gg/X8pfZpZHnR",
+      "x": "https://x.com/irismd"
+    }
+  },
+  "integrations": {
+    "ga4": {
+      "measurementId": "G-Z6L00G5P4N"
+    }
+  }
+}