codingbuddy-rules 0.0.0-canary.20260106162449.5ea2cce → 0.0.0-canary.20260107011541.g12891ae

package/.ai-rules/adapters/antigravity.md

@@ -187,6 +187,86 @@ AI: # Mode: EVAL
 - ✅ Access to all specialist agent knowledge
 - ✅ Easy to update: change `.ai-rules/` once, all tools benefit
 
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+User: AUTO 새로운 결제 시스템 기능 만들어줘
+
+AI: # Mode: AUTO (Iteration 1/3)
+    ## Phase: PLAN
+    [Following .ai-rules/rules/core.md workflow]
+
+    ## Phase: ACT
+    [Execute with .ai-rules guidelines]
+
+    ## Phase: EVAL
+    [Evaluate with quality criteria]
+
+    ### Quality Status
+    - Critical: 0
+    - High: 0
+
+    ✅ AUTO mode completed successfully!
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### Antigravity-Specific Integration
+
+AUTO mode works with Antigravity's task boundary tracking:
+
+```python
+task_boundary(
+  TaskName="AUTO: Feature Implementation",
+  Mode="AUTO_ITERATION",
+  TaskSummary="Iteration 1/3 - PLAN phase completed",
+  TaskStatus="Executing ACT phase",
+  PredictedTaskSize=30
+)
+```
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria
+
 ## Maintenance
 
 When updating rules:

package/.ai-rules/adapters/claude-code.md

@@ -450,3 +450,93 @@ Each workflow mode activates different specialist agents:
 - **EVAL mode**: Security, accessibility, performance, and code quality specialists provide comprehensive review
 
 **Important:** Specialists from one mode do NOT carry over to the next mode. Each mode has its own recommended specialist set.
+
+## AUTO Mode
+
+AUTO mode enables autonomous iteration through PLAN -> ACT -> EVAL cycles until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+AUTO implement user authentication with JWT tokens
+```
+
+```
+자동 사용자 인증 기능을 JWT로 구현해줘
+```
+
+### Expected Behavior
+
+1. **Initial PLAN**: Creates implementation plan with quality criteria
+2. **ACT Iteration**: Executes implementation following TDD workflow
+3. **EVAL Check**: Evaluates quality against exit criteria
+4. **Loop or Exit**:
+   - If quality met (Critical=0, High=0): Exits with success summary
+   - If max iterations reached: Exits with failure summary and remaining issues
+   - Otherwise: Returns to PLAN with improvement focus
+
+### Exit Criteria
+
+- **Success**: `Critical = 0 AND High = 0` severity issues
+- **Failure**: Max iterations reached (default: 3, configurable via `auto.maxIterations`)
+
+### Configuration
+
+Configure AUTO mode in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3  // Default: 3
+  }
+};
+```
+
+### AUTO Mode Output Format
+
+```
+# Mode: AUTO (Iteration 1/3)
+
+## Phase: PLAN
+[Planning content...]
+
+## Phase: ACT
+[Implementation content...]
+
+## Phase: EVAL
+[Evaluation content...]
+
+### Quality Status
+- Critical: 0
+- High: 0
+
+✅ AUTO mode completed successfully!
+```
+
+### When to Use AUTO Mode
+
+- **Large feature implementations** that require multiple refinement cycles
+- **Complex refactoring** where quality verification is critical
+- **Bug fixes** that need comprehensive testing and validation
+- **Code quality improvements** with measurable success criteria
+
+### Differences from Manual Mode Flow
+
+| Aspect | Manual Mode | AUTO Mode |
+|--------|-------------|-----------|
+| Transition | User triggers each mode | Automatic cycling |
+| Iterations | Single pass per mode | Multiple cycles until quality met |
+| Exit | User decides completion | Quality criteria or max iterations |
+| Intervention | Required for each step | Only when requested or on failure |

package/.ai-rules/adapters/codex.md

@@ -147,3 +147,60 @@ Skills are located in `.ai-rules/skills/`. To use a skill:
 - `subagent-driven-development` - In-session plan execution
 - `dispatching-parallel-agents` - Handle parallel tasks
 - `frontend-design` - Build production-grade UI
+
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+AUTO implement user authentication with JWT
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### Copilot Integration
+
+When using GitHub Copilot Chat with AUTO mode:
+- Copilot references `.ai-rules/rules/core.md` for workflow
+- Applies `.ai-rules/rules/augmented-coding.md` TDD principles
+- Uses project structure from `.ai-rules/rules/project.md`
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria

package/.ai-rules/adapters/cursor.md

@@ -166,6 +166,62 @@ This project uses codingbuddy MCP server to manage AI Agents.
 
 See `AGENTS.md` in project root for details.
 
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+AUTO implement user authentication feature
+```
+
+```
+자동 사용자 인증 기능 구현해줘
+```
+
+When AUTO keyword is detected, Cursor calls `parse_mode` MCP tool which returns AUTO mode instructions.
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria
+
 ## Reference
 
 - [AGENTS.md Official Spec](https://agents.md)

package/.ai-rules/adapters/kiro.md

@@ -122,9 +122,75 @@ Kiro will generate code following:
 2. Update `.kiro/rules/guidelines.md` only for Kiro-specific features
 3. Common rules propagate automatically to all Kiro sessions
 
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+User: AUTO 새로운 컴포넌트 구현해줘
+
+Kiro: # Mode: AUTO (Iteration 1/3)
+      ## Phase: PLAN
+      [Follows .ai-rules/rules/core.md workflow]
+
+      ## Phase: ACT
+      [Executes with quality standards from .ai-rules]
+
+      ## Phase: EVAL
+      [Evaluates against quality criteria]
+
+      ### Quality Status
+      - Critical: 0
+      - High: 0
+
+      ✅ AUTO mode completed successfully!
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria
+
 ## Getting Started
 
 1. Ensure `.ai-rules/` directory exists with all common rules
 2. Create `.kiro/rules/guidelines.md` with content above
 3. Start a Kiro session - it will automatically reference common rules
-4. Use PLAN/ACT/EVAL workflow as defined in `.ai-rules/rules/core.md`
+4. Use PLAN/ACT/EVAL/AUTO workflow as defined in `.ai-rules/rules/core.md`

package/.ai-rules/adapters/opencode.md

@@ -545,6 +545,97 @@ API 엔드포인트 구현
 보안 취약점 검사
 ```
 
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```bash
+# Start AUTO mode
+/agent plan-mode
+AUTO 새로운 사용자 인증 기능을 만들어줘
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria (read-only)
+2. **ACT Phase**: Executes implementation following TDD workflow (full permissions)
+3. **EVAL Phase**: Evaluates quality against exit criteria (read-only)
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### OpenCode Agent Integration
+
+AUTO mode automatically switches between agents:
+
+```
+AUTO detected
+    ↓
+plan-mode agent (PLAN phase)
+    ↓
+act-mode agent (ACT phase)
+    ↓
+eval-mode agent (EVAL phase)
+    ↓
+[Check quality criteria]
+    ↓
+Loop or Exit
+```
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### AUTO Mode Output Format
+
+```
+# Mode: AUTO (Iteration 1/3)
+
+## Phase: PLAN
+[Planning with plan-mode agent...]
+
+## Phase: ACT
+[Implementation with act-mode agent...]
+
+## Phase: EVAL
+[Evaluation with eval-mode agent...]
+
+### Quality Status
+- Critical: 0
+- High: 0
+
+✅ AUTO mode completed successfully!
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria
+
 ---
 
 This guide ensures consistent, high-quality AI-assisted development using OpenCode/Crush with the `.ai-rules` system. All agents follow the same standards while leveraging OpenCode's powerful terminal-based interface.

package/.ai-rules/adapters/q.md

@@ -119,6 +119,63 @@ Combine Q's AWS expertise with project rules:
 - Let Q provide AWS-specific security guidance
 - Apply `.ai-rules/agents/devops-engineer.json` for deployment patterns
 
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+AUTO 새로운 Lambda 함수 만들어줘
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### AWS Integration with AUTO Mode
+
+Amazon Q's AWS expertise complements AUTO mode:
+- Leverages Q's security scanning during EVAL phase
+- Applies AWS best practices during ACT phase
+- Uses Q's cost optimization suggestions in planning
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- AWS service integrations needing thorough testing
+- Infrastructure as Code development with validation cycles
+
 ## Maintenance
 
 1. Update `.ai-rules/rules/*.md` for universal changes

package/.ai-rules/rules/core.md

@@ -2,11 +2,12 @@
 
 ### Work Modes
 
-You have three modes of operation:
+You have four modes of operation:
 
 1. **Plan mode** - Define a plan without making changes
 2. **Act mode** - Execute the plan and make changes
 3. **Eval mode** - Analyze results and propose improvements
+4. **Auto mode** - Autonomous execution cycling PLAN → ACT → EVAL until quality achieved
 
 **Mode Rules:**
 - Start in PLAN mode by default
@@ -16,6 +17,8 @@ You have three modes of operation:
 - EVAL mode analyzes ACT results and proposes improved PLAN
 - After EVAL completes, return to PLAN mode with improvement suggestions
 - User can repeat ACT → EVAL → PLAN cycle until satisfied
+- Move to AUTO mode when user types `AUTO` (or localized: 자동, 自動, 自动, AUTOMÁTICO)
+- AUTO mode autonomously cycles through PLAN → ACT → EVAL until quality targets met
 - When in plan mode always output the full updated plan in every response
 
 **Default Flow:**
@@ -28,12 +31,18 @@ PLAN → (user: ACT) → ACT → PLAN (automatic return)
 PLAN → (user: ACT) → ACT → PLAN → (user: EVAL) → EVAL → Improved PLAN
 ```
 
-**Key Point:** EVAL is opt-in, not automatic. User must explicitly request evaluation.
+**Autonomous Flow:**
+```
+(user: AUTO) → AUTO [PLAN → ACT → EVAL → repeat until Critical=0 AND High=0]
+```
+
+**Key Point:** EVAL is opt-in, not automatic. User must explicitly request evaluation. AUTO mode handles the entire cycle automatically.
 
 **Mode Indicators:**
 - Print `# Mode: PLAN` in plan mode
 - Print `# Mode: ACT` in act mode
 - Print `# Mode: EVAL` in eval mode
+- Print `# Mode: AUTO` in auto mode (with iteration number)
 
 ---
 
@@ -672,6 +681,181 @@ Self-improvement through iterative refinement
 - Already meeting all standards
 - Time-sensitive quick fixes
 
+---
+
+### Auto Mode
+
+**Important:**
+- AUTO mode is an **autonomous execution mode** that cycles through PLAN → ACT → EVAL automatically
+- User initiates with `AUTO` keyword and the system handles the entire workflow
+- Continues iterating until quality targets are achieved or maximum iterations reached
+- Best for tasks where iterative refinement is expected
+
+**Trigger:**
+- Type `AUTO` to start autonomous execution
+- Korean: `자동`
+- Japanese: `自動`
+- Chinese: `自动`
+- Spanish: `AUTOMÁTICO`
+
+**Purpose:**
+Autonomous iterative development - automatically cycling through planning, implementation, and evaluation until quality standards are met.
+
+**How AUTO Works:**
+
+1. **Initial Phase: PLAN**
+   - Creates implementation plan following TDD and augmented coding principles
+   - Activates Primary Developer Agent automatically
+   - Outputs structured plan with todo items
+
+2. **Execution Phase: ACT**
+   - Executes the plan created in PLAN phase
+   - Follows TDD cycle for core logic, Test-After for UI
+   - Maintains quality standards throughout
+
+3. **Evaluation Phase: EVAL**
+   - Automatically evaluates the implementation (no user prompt required)
+   - Activates Code Reviewer Agent
+   - Assesses quality across all mandatory perspectives
+   - Categorizes issues by severity: Critical, High, Medium, Low
+
+4. **Iteration Decision:**
+   - **Success (Exit):** Critical = 0 AND High = 0 → Complete with success summary
+   - **Continue:** Critical > 0 OR High > 0 → Return to PLAN with improvements
+   - **Failure (Exit):** Max iterations reached → Transition to PLAN mode with suggestions
+
+**Exit Conditions:**
+
+| Condition | Result | Next Action |
+|-----------|--------|-------------|
+| Critical = 0 AND High = 0 | Success | Display completion summary |
+| Max iterations reached | Failure | Transition to PLAN with remaining issues |
+| User interruption | Stopped | Return control to user |
+
+**Configuration:**
+
+| Parameter | Default | Range | Description |
+|-----------|---------|-------|-------------|
+| `auto.maxIterations` | 3 | 1-10 | Maximum PLAN→ACT→EVAL cycles before forced exit |
+
+**🔴 Agent Activation (STRICT):**
+- When AUTO mode is triggered, **Primary Developer Agent** (e.g., `.ai-rules/agents/frontend-developer.json`) **MUST** be automatically activated for PLAN and ACT phases
+- During EVAL phase, **Code Reviewer Agent** (`.ai-rules/agents/code-reviewer.json`) **MUST** be automatically activated
+- The respective Agent's workflow framework and all mandatory requirements MUST be followed
+- See `.ai-rules/agents/` for complete agent frameworks
+
+**Output Format:**
+```
+# Mode: AUTO
+## Autonomous Execution Started
+
+Task: [Task description]
+Max Iterations: [maxIterations]
+
+---
+
+## Iteration 1/[maxIterations] - PLAN Phase
+[Standard PLAN mode output]
+
+---
+## Iteration 1/[maxIterations] - ACT Phase
+[Standard ACT mode output]
+
+---
+## Iteration 1/[maxIterations] - EVAL Phase
+[Standard EVAL mode output]
+
+Issues Found:
+- Critical: [N]
+- High: [N] <- 반복 필요 (if Critical > 0 OR High > 0)
+- Medium: [N]
+- Low: [N]
+
+[If continue iteration: proceed to next iteration]
+[If success: display completion format]
+[If max iterations: display failure format]
+```
+
+**Success Completion Format:**
+```
+---
+# Mode: AUTO - COMPLETED
+
+Task completed successfully!
+Final Stats:
+- Iterations: [N]/[maxIterations]
+- Critical: 0, High: 0
+- Medium: [N], Low: [N]
+
+Modified Files:
+- [file1]
+- [file2]
+```
+
+**Failure (Max Iterations) Format:**
+```
+---
+# Mode: AUTO - MAX ITERATIONS REACHED
+
+[maxIterations]회 시도했지만 일부 이슈가 남아있습니다.
+
+Remaining Issues:
+- [CRITICAL] [Issue description]
+- [HIGH] [Issue description]
+
+시도한 접근:
+- Iteration 1: [approach]
+- Iteration 2: [approach]
+- Iteration 3: [approach]
+
+---
+# Mode: PLAN
+```
+
+**When to use AUTO:**
+- Complex features requiring multiple refinement cycles
+- Tasks where iterative improvement is expected
+- When you want hands-off development until quality is achieved
+- Production-critical code requiring thorough quality assurance
+- Large implementations that benefit from systematic iteration
+
+**When to use manual workflow instead:**
+- Simple, single-step implementations
+- When you want fine-grained control over each phase
+- Exploratory development where direction may change
+- Time-sensitive tasks that shouldn't iterate
+- When specific phase customization is needed
+
+**AUTO vs Manual Comparison:**
+
+| Aspect | AUTO Mode | Manual (PLAN/ACT/EVAL) |
+|--------|-----------|------------------------|
+| User intervention | Minimal (start only) | Required for each phase |
+| Iteration control | Automatic | User-controlled |
+| Best for | Complex, iterative tasks | Simple or exploratory tasks |
+| Quality guarantee | Enforced (exit conditions) | User judgment |
+| Time efficiency | Optimized for quality | Optimized for control |
+
+**🔴 Required:**
+- All PLAN phases must follow the Primary Developer Agent's workflow framework
+- All ACT phases must follow the Primary Developer Agent's code quality checklist
+- All EVAL phases must follow the Code Reviewer Agent's evaluation framework
+- Respond in the language specified in the agent's communication.language setting
+- Continue iterating automatically until exit conditions are met (Critical = 0 AND High = 0)
+- Transition to PLAN mode with remaining issues when max iterations reached
+
+**Verification:**
+- Mode indicator `# Mode: AUTO` should be first line at start
+- Task description and max iterations should be displayed in start header
+- Each iteration should display phase indicator: `## Iteration N/[maxIterations] - [Phase] Phase`
+- EVAL phase must include issues summary with Critical, High, Medium, Low counts
+- Success completion should display `# Mode: AUTO - COMPLETED`
+- Failure completion should display `# Mode: AUTO - MAX ITERATIONS REACHED`
+- Exit conditions should be evaluated after each EVAL phase
+- Agent activation rules from PLAN, ACT, EVAL modes apply to respective phases within AUTO mode
+
+---
+
 ### Communication Rules
 
 - **Respond in the language specified in the agent's communication.language setting**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codingbuddy-rules",
-  "version": "0.0.0-canary.20260106162449.5ea2cce",
+  "version": "0.0.0-canary.20260107011541.g12891ae",
   "description": "AI coding rules for consistent practices across AI assistants",
   "main": "index.js",
   "types": "index.d.ts",