cokit-cli 1.0.1 → 1.0.2

package/plans/260108-0924-rebuild-cokit-awesome-copilot-format/phase-07-update-documentation.md

@@ -0,0 +1,407 @@
+# Phase 7: Update Documentation
+
+## Context Links
+- [Main Plan](./plan.md)
+- [Phase 6: Update CLI](./phase-06-update-cli-build-scripts.md)
+
+## Overview
+
+| Priority | Status | Effort |
+|----------|--------|--------|
+| P2 | pending | 1h |
+
+## Key Insights
+
+1. AGENTS.md la project instructions cho AI tools
+2. README.md la user-facing documentation
+3. Category READMEs generated by build script
+4. Migration guide cho users tu old CoKit
+
+## Requirements
+
+### Documentation Files
+
+| File | Purpose | Audience |
+|------|---------|----------|
+| `AGENTS.md` | Project instructions for AI | AI tools |
+| `README.md` | Main documentation | Users |
+| `QUICK-START.md` | Quick setup guide | New users |
+| `FAQ.md` | Common questions | Users |
+| `docs/migration-guide.md` | Migration from old CoKit | Existing users |
+| `docs/README.agents.md` | Agent listing | Generated |
+| `docs/README.prompts.md` | Prompt listing | Generated |
+| `docs/README.instructions.md` | Instruction listing | Generated |
+| `docs/README.skills.md` | Skills listing | Generated |
+| `docs/README.collections.md` | Collection listing | Generated |
+
+## Implementation Steps
+
+### Step 1: Create AGENTS.md
+
+```markdown
+# AGENTS.md
+
+## Project Overview
+
+CoKit is a CLI tool that generates GitHub Copilot customizations from ClaudeKit content. The project follows the Awesome Copilot format specification.
+
+## Repository Structure
+
+```
+.
+├── agents/           # Custom agents (.agent.md)
+├── prompts/          # Reusable prompts (.prompt.md)
+├── instructions/     # Coding standards (.instructions.md)
+├── skills/           # Agent skills with assets
+├── collections/      # Curated collections (.collection.yml)
+├── docs/             # Generated documentation
+├── eng/              # Build scripts
+├── src/              # CLI source code
+├── templates/        # Project templates
+└── bin/              # CLI entrypoint
+```
+
+## Development Workflow
+
+### Building
+
+```bash
+npm run build          # Generate README files
+```
+
+### Validation
+
+```bash
+npm run collection:validate   # Validate collections
+npm run skill:validate        # Validate skills
+```
+
+### Creating Resources
+
+```bash
+npm run collection:create -- --id <id>
+npm run skill:create -- --name <name>
+```
+
+## File Formats
+
+### Agent Files (*.agent.md)
+
+```yaml
+---
+description: 'Agent description'
+model: 'GPT-4.1'
+tools: ['search', 'read']
+---
+```
+
+### Prompt Files (*.prompt.md)
+
+```yaml
+---
+agent: 'agent'
+description: 'Prompt description'
+---
+```
+
+### Instruction Files (*.instructions.md)
+
+```yaml
+---
+description: 'Instruction description'
+applyTo: '**/*.ts'
+---
+```
+
+### Skill Files (skills/*/SKILL.md)
+
+```yaml
+---
+name: 'skill-name'
+description: 'Skill description (10-1024 chars)'
+---
+```
+
+## Code Style
+
+- Use ES modules (.mjs for scripts)
+- Lowercase with hyphens for filenames
+- Single quotes in YAML frontmatter
+- UTF-8 encoding, LF line endings
+
+## Testing
+
+Run CLI locally:
+
+```bash
+node bin/cokit.js init --yes
+node bin/cokit.js list
+node bin/cokit.js doctor
+```
+
+## Contributing
+
+1. Add files to appropriate directory
+2. Include required frontmatter
+3. Run `npm run build`
+4. Test with `cokit doctor`
+```
+
+### Step 2: Update README.md
+
+```markdown
+# CoKit
+
+Make GitHub Copilot smarter in 30 seconds.
+
+[![npm version](https://img.shields.io/npm/v/cokit.svg)](https://www.npmjs.com/package/cokit)
+
+## Quick Start
+
+```bash
+npx cokit init
+```
+
+That's it! Now open VS Code and try `/ck-fix` in Copilot Chat.
+
+## What You Get
+
+### Prompts (type in Copilot Chat)
+
+| Command | What it does |
+|---------|--------------|
+| `/ck-fix` | Debug and fix code issues |
+| `/ck-plan` | Create implementation plans |
+| `/ck-code` | Implement from a plan |
+| `/ck-test` | Write tests for your code |
+| `/ck-review` | Review code before committing |
+| `/ck-docs` | Update documentation |
+
+### Instructions (auto-applied)
+
+Instructions automatically enhance Copilot for specific file types:
+- Frontend: React, Vue, Svelte best practices
+- Backend: Node.js, Python, .NET patterns
+- DevOps: Docker, CI/CD guidelines
+
+### Collections
+
+Curated sets of prompts, instructions, and agents:
+- **ck-core**: Essential prompts
+- **ck-fixing**: Bug fixing toolkit
+- **ck-planning**: Planning tools
+- **ck-frontend**: Frontend development
+- **ck-backend**: Backend development
+
+## Installation Options
+
+### Project Only (Recommended)
+
+```bash
+npx cokit init
+```
+
+Creates files in `.github/` - share with your team via git.
+
+### Global Installation
+
+```bash
+npx cokit init --global
+```
+
+Creates files in `~/.copilot/` - works in all projects.
+
+### Both
+
+```bash
+npx cokit init --all
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `cokit init` | Set up CoKit |
+| `cokit add <name>` | Add specific prompt/instruction |
+| `cokit list` | Show available resources |
+| `cokit doctor` | Check your setup |
+| `cokit update` | Update to latest version |
+
+## Documentation
+
+- [Quick Start](QUICK-START.md)
+- [FAQ](FAQ.md)
+- [Migration Guide](docs/migration-guide.md)
+- [Prompts](docs/README.prompts.md)
+- [Instructions](docs/README.instructions.md)
+- [Collections](docs/README.collections.md)
+
+## For Claude Code Users
+
+Migrating from Claude Code? See [Migration Guide](docs/migration-guide.md).
+
+Key differences:
+- No hooks (static config only)
+- No subagents (single Copilot agent)
+- No `$ARGUMENTS` (user provides context in chat)
+
+## License
+
+CC BY-NC 4.0 - Free for personal and educational use.
+```
+
+### Step 3: Update docs/migration-guide.md
+
+```markdown
+# Migration Guide
+
+## From Old CoKit (v1.x)
+
+If you used the previous version of CoKit:
+
+1. Remove old files:
+   ```bash
+   rm -rf .github/copilot-instructions.md
+   rm -rf ~/.copilot/skills/
+   ```
+
+2. Run new setup:
+   ```bash
+   npx cokit init --all
+   ```
+
+## From Claude Code
+
+### Key Differences
+
+| Feature | Claude Code | CoKit/Copilot |
+|---------|-------------|---------------|
+| Commands | Slash commands with `$ARGUMENTS` | Prompts, type `/ck-*` |
+| Agents | Subagents via Task tool | Single agent |
+| Skills | Auto-loaded from ~/.claude/skills/ | Manual via instructions |
+| Hooks | Pre/post hooks | Not supported |
+| Context | Session state | Chat context only |
+
+### Command Mapping
+
+| Claude Code | CoKit |
+|-------------|-------|
+| `/fix <issue>` | `/ck-fix` then describe issue |
+| `/plan <task>` | `/ck-plan` then describe task |
+| `/code <plan>` | `/ck-code` then reference plan |
+| `/test` | `/ck-test` |
+
+### What Works the Same
+
+- Core prompts have same intent
+- Instructions apply automatically
+- Skills provide specialized knowledge
+
+### What's Different
+
+1. **No Arguments**: Instead of `/fix $ARGUMENTS`, type `/ck-fix` then describe the issue in chat.
+
+2. **No Subagents**: Claude Code delegates to specialized agents. Copilot uses a single agent with loaded instructions.
+
+3. **No Hooks**: Claude Code supports pre/post hooks. Copilot uses static configuration only.
+
+4. **No Session State**: Claude Code maintains state across commands. Copilot uses chat context.
+
+### Tips for Transition
+
+1. Be more explicit in chat since there's no argument passing
+2. Reference files explicitly instead of relying on context
+3. Use multiple prompts for complex workflows
+4. Load relevant instructions before starting
+```
+
+### Step 4: Update QUICK-START.md
+
+```markdown
+# Quick Start
+
+## 30-Second Setup
+
+```bash
+npx cokit init
+```
+
+## Use in VS Code
+
+1. Open VS Code
+2. Open Copilot Chat (Ctrl+Shift+I)
+3. Type `/ck-fix` and describe an issue
+
+## Core Prompts
+
+| Type | What to do |
+|------|------------|
+| `/ck-fix` | Debug code issues |
+| `/ck-plan` | Plan before coding |
+| `/ck-code` | Implement a plan |
+| `/ck-test` | Write tests |
+
+## Next Steps
+
+- Run `cokit list` to see all available prompts
+- Run `cokit doctor` to check your setup
+- See [FAQ](FAQ.md) for common questions
+```
+
+### Step 5: Update FAQ.md
+
+```markdown
+# FAQ
+
+## General
+
+**Q: What is CoKit?**
+A: CoKit generates GitHub Copilot customizations from ClaudeKit content.
+
+**Q: Is CoKit free?**
+A: Free for personal and educational use (CC BY-NC 4.0).
+
+## Installation
+
+**Q: Where are files installed?**
+A: Project mode installs to `.github/`, global mode to `~/.copilot/`.
+
+**Q: Can I use both project and global?**
+A: Yes! Run `cokit init --all`.
+
+## Usage
+
+**Q: Why `/ck-` prefix?**
+A: Prevents conflicts with other tools. Easy to identify CoKit prompts.
+
+**Q: How do I pass arguments?**
+A: Type the prompt first, then describe your request in chat.
+
+## Troubleshooting
+
+**Q: Prompts not showing?**
+A: Restart VS Code after running `cokit init`.
+
+**Q: Skills not working?**
+A: Enable in VS Code: Settings > `github.copilot.chat.useAgentSkills`.
+
+**Q: How do I update?**
+A: Run `cokit update` or `npx cokit@latest init --overwrite`.
+```
+
+## Success Criteria
+
+- [ ] AGENTS.md created with project instructions
+- [ ] README.md updated for new structure
+- [ ] Migration guide covers Claude Code transition
+- [ ] QUICK-START.md is concise and actionable
+- [ ] FAQ.md answers common questions
+- [ ] All docs use consistent formatting
+
+## Risk Assessment
+
+| Risk | Probability | Impact | Mitigation |
+|------|-------------|--------|------------|
+| Outdated documentation | Medium | Low | Generate from source |
+| Missing migration steps | Medium | Medium | Test migration path |
+| Inconsistent formatting | Low | Low | Use markdown linter |

package/plans/260108-0924-rebuild-cokit-awesome-copilot-format/plan.md

@@ -0,0 +1,136 @@
+---
+title: 'Rebuild CoKit to Awesome Copilot Format'
+description: 'Restructure CoKit to generate GitHub Copilot customizations from ClaudeKit content using Awesome Copilot format'
+status: pending
+priority: P1
+effort: 16h
+branch: master
+tags: [cokit, copilot, restructure, migration]
+created: 2026-01-08
+---
+
+# Rebuild CoKit to Awesome Copilot Format
+
+## Executive Summary
+
+Rebuild CoKit theo cau truc Awesome Copilot format de generate GitHub Copilot customizations tu ClaudeKit content. Project nay se chuyen doi 17 agents, 71 commands, 38+ skills, va 4 workflows thanh format tuong thich voi Copilot.
+
+## Source Analysis
+
+### ClaudeKit Content (~/.claude/)
+
+| Category | Count | Source Path | Format |
+|----------|-------|-------------|--------|
+| Agents | 17 | `~/.claude/agents/*.md` | YAML frontmatter + markdown |
+| Commands | 71 | `~/.claude/commands/ck/**/*.md` | Nested folders, `$ARGUMENTS` vars |
+| Skills | 38 | `~/.claude/skills/*/SKILL.md` | SKILL.md + bundled assets |
+| Workflows | 4 | `~/.claude/workflows/*.md` | Pure markdown |
+
+### Awesome Copilot Target Format
+
+| Category | Extension | Required Fields | Path |
+|----------|-----------|-----------------|------|
+| Agents | `.agent.md` | `description`, recommend `model`, `tools` | `agents/` |
+| Prompts | `.prompt.md` | `agent`, `description` | `prompts/` |
+| Instructions | `.instructions.md` | `description`, `applyTo` | `instructions/` |
+| Skills | `SKILL.md` | `name`, `description` | `skills/*/` |
+| Collections | `.collection.yml` | `id`, `name`, `description`, `items` | `collections/` |
+
+## Conversion Mapping
+
+```
+ClaudeKit                    → Awesome Copilot
+─────────────────────────────────────────────────
+agents/*.md                  → agents/*.agent.md
+commands/ck/**/*.md          → prompts/ck-*.prompt.md (flattened)
+skills/simple (text only)    → instructions/*.instructions.md
+skills/complex (with assets) → skills/*/SKILL.md
+workflows/*.md               → collections/*.collection.yml
+```
+
+## Implementation Phases
+
+### Phase 1: Restructure Folders (1h)
+- Create Awesome Copilot directory structure
+- Add `.schemas/collection.schema.json`
+- Setup `eng/` build scripts folder
+
+### Phase 2: Convert Agents (2h)
+- Convert 17 agents to `.agent.md` format
+- Add required frontmatter fields
+- Map model names (opus → GPT-4.1, sonnet → GPT-4.0)
+
+### Phase 3: Convert Commands to Prompts (4h)
+- Flatten 71 nested commands
+- Create `ck-` prefixed prompts
+- Replace `$ARGUMENTS` with placeholder instructions
+
+### Phase 4: Convert Skills to Instructions (4h)
+- Analyze 38 skills for complexity
+- Simple skills → instructions with `applyTo`
+- Complex skills → skills folders with assets
+
+### Phase 5: Create Collections (2h)
+- Convert 4 workflows to collections
+- Create curated collections (ck-core, ck-code, etc.)
+
+### Phase 6: Update CLI & Build Scripts (2h)
+- Update `src/commands/init.js`
+- Add eng/ scripts (update-readme.mjs, validate-*.mjs)
+
+### Phase 7: Update Documentation (1h)
+- Create AGENTS.md
+- Update README.md
+- Add docs/ READMEs
+
+## File Deliverables
+
+| Phase | Files Created |
+|-------|---------------|
+| 1 | 6 directories + schema |
+| 2 | 17 agent files |
+| 3 | ~71 prompt files |
+| 4 | ~25 instruction + ~13 skill folders |
+| 5 | 5+ collection files |
+| 6 | 7+ eng scripts |
+| 7 | 4+ doc files |
+
+## Dependencies
+
+- Node.js 18+
+- js-yaml package (for collection parsing)
+- vfile-matter package (for frontmatter parsing)
+
+## Risk Assessment
+
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| Breaking CLI compatibility | High | Maintain backward-compatible init command |
+| Content loss during conversion | Medium | Manual review of each conversion |
+| Format validation failures | Low | Add validation scripts |
+
+## Success Criteria
+
+1. All 17 agents converted with valid frontmatter
+2. All 71 commands converted to prompts with `ck-` prefix
+3. Skills properly categorized (instructions vs skills)
+4. Collections created from workflows
+5. `npx cokit init` works correctly
+6. Build scripts generate README.md
+
+## Phase Details
+
+Xem chi tiet trong cac file:
+- [Phase 1: Restructure Folders](./phase-01-restructure-folders.md)
+- [Phase 2: Convert Agents](./phase-02-convert-agents.md)
+- [Phase 3: Convert Commands to Prompts](./phase-03-convert-commands-to-prompts.md)
+- [Phase 4: Convert Skills to Instructions](./phase-04-convert-skills-to-instructions.md)
+- [Phase 5: Create Collections](./phase-05-create-collections.md)
+- [Phase 6: Update CLI & Build Scripts](./phase-06-update-cli-build-scripts.md)
+- [Phase 7: Update Documentation](./phase-07-update-documentation.md)
+
+## Unresolved Questions
+
+1. Nen giu license CC BY-NC 4.0 hay chuyen sang MIT?
+2. Co can tao MCP server rieng cho CoKit?
+3. Cach xu ly `$ARGUMENTS` variable trong prompts - placeholder text hay remove?

package/prompts/ck-ask.prompt.md

@@ -0,0 +1,57 @@
+---
+agent: 'agent'
+description: 'Answer technical and architectural questions.'
+tools: ['search/changes', 'search/codebase', 'web/fetch', 'web/githubRepo', 'read/problems', 'search/usages']
+---
+
+## Context
+Technical question or architecture challenge:
+<questions>${input}</questions>
+
+Current development workflows, system constraints, scale requirements, and business context will be considered:
+- Primary workflow: 
+- Development rules: 
+- Orchestration protocols: 
+- Documentation management: 
+
+**Project Documentation:**
+```
+./docs
+├── project-overview-pdr.md
+├── 
+├── codebase-summary.md
+├── design-guidelines.md
+├── deployment-guide.md
+├── system-architecture.md
+└── project-roadmap.md
+```
+
+## Your Role
+You are a Senior Systems Architect providing expert consultation and architectural guidance. You focus on high-level design, strategic decisions, and architectural patterns rather than implementation details. You orchestrate four specialized architectural advisors:
+1. **Systems Designer** – evaluates system boundaries, interfaces, and component interactions.
+2. **Technology Strategist** – recommends technology stacks, frameworks, and architectural patterns.
+3. **Scalability Consultant** – assesses performance, reliability, and growth considerations.
+4. **Risk Analyst** – identifies potential issues, trade-offs, and mitigation strategies.
+You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
+
+## Process
+1. **Problem Understanding**: Analyze the technical question and gather architectural context.
+   - If the architecture context doesn't contain the necessary information, use [`SlashCommand()`]() to scout the codebase again.
+2. **Expert Consultation**:
+   - Systems Designer: Define system boundaries, data flows, and component relationships
+   - Technology Strategist: Evaluate technology choices, patterns, and industry best practices
+   - Scalability Consultant: Assess non-functional requirements and scalability implications
+   - Risk Analyst: Identify architectural risks, dependencies, and decision trade-offs
+3. **Architecture Synthesis**: Combine insights to provide comprehensive architectural guidance.
+4. **Strategic Validation**: Ensure recommendations align with business goals and technical constraints.
+
+## Output Format
+**Be honest, be brutal, straight to the point, and be concise.**
+1. **Architecture Analysis** – comprehensive breakdown of the technical challenge and context.
+2. **Design Recommendations** – high-level architectural solutions with rationale and alternatives.
+3. **Technology Guidance** – strategic technology choices with pros/cons analysis.
+4. **Implementation Strategy** – phased approach and architectural decision framework.
+5. **Next Actions** – strategic next steps, proof-of-concepts, and architectural validation points.
+
+## Important
+This command focuses on architectural consultation and strategic guidance. Do not start implementing anything.

package/prompts/ck-bootstrap-auto-fast.prompt.md

@@ -0,0 +1,108 @@
+---
+agent: 'agent'
+description: 'Quickly bootstrap a new project automatically'
+tools: ['search/codebase', 'search/changes', 'web/fetch', 'web/githubRepo', 'read/terminalLastCommand']
+---
+
+**Think hard** to plan & bootstrap a new project follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules in your `CLAUDE.md` file:
+
+---
+
+## User's Objectives & Requirements
+
+<user-requirements>${input}</user-requirements>
+
+---
+
+## Role Responsibilities
+
+- You are an elite software engineering expert who specializes in system architecture design and technical decision-making. 
+- Your core mission is to find the best possible solutions while maintaining brutal honesty about feasibility and trade-offs, then collaborate with your  implement the plan.
+- You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
+
+- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+
+---
+
+## Your Approach
+
+1. **Brutal Honesty**: Provide frank, unfiltered feedback about ideas. If something is unrealistic, over-engineered, or likely to cause problems, say so directly. Your job is to prevent costly mistakes.
+2. **Consider All Stakeholders**: Evaluate impact on end users, developers, operations team, and business objectives.
+
+---
+
+## Workflow:
+
+Follow strictly these following steps:
+
+**First thing first:** check if Git has been initialized, if not, quickly initialize it (use `main` branch).
+
+**IMPORTANT:** 
+
+### Research & Planning: Tech Stack, Wireframe & Design
+
+1. **Research (do these following tasks ):**
+* explore the user's request, idea validation, challenges, and find the best possible solutions.
+* find a best fit tech stack for this project.
+* create a design plan that follows the progressive disclosure structure:
+  - Create a directory using naming pattern from `## Naming` section.
+  - Save the overview access point at `plan.md`, keep it generic, under 80 lines, and list each phase with status/progress and links.
+  - For each phase, add `phase-XX-phase-name.md` files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
+* Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations.
+   - **Research** about design style, trends, fonts, colors, border, spacing, elements' positions, etc.
+   - Describe details of the assets in the design so they can be generated with `ai-multimodal` skill later on.
+   - **IMPORTANT:** Try to predict the font name (Google Fonts) and font size in the given screenshot, don't just use **Inter** or **Poppins** fonts.
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+2. **Planning (do these following tasks one after another):**
+* analyze the research results and create the design guidelines at `./docs/design-guidelines.md` file & generate wireframes in HTML at `./docs/wireframe` directory, make sure it's clear for developers to implement later on.
+* If there are no logo provided, 
+* /docs/wireframes/` directory.
+* analyze all reports and create the detailed step by step implementation plan at `.s` directory following the progressive disclosure structure above.
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+### Implementation
+
+* Use `general agent (main agent)` to implement the plan step by step, follow the implementation plan in `.s` directory.
+* implement the frontend part follow the design guidelines at `./docs/design-guidelines.md` file.
+  * Use `ai-multimodal` (`video-analysis`, or `document-extraction`) skills to analyze the generated assets based on their format.
+  * Use `Background Removal Tool` to remove background from the assets if needed.
+  * Use `ai-multimodal` (`image-generation`) skill to edit the assets if needed.
+* Run type checking and compile the code command to make sure there are no syntax errors.
+
+### Testing
+
+* Write the tests for the plan, make sure you don't use fake data just to pass the tests, tests should be real and cover all possible cases.
+* run the tests, make sure all tests pass and the app is working, .
+* If there are issues or failed tests, find the root cause of the issues, then ask main agent to fix all of them. 
+* Repeat the process until all tests pass or no more issues are reported. 
+* **Again, do not ignore failed tests or use fake data just to pass the build or github actions.**
+
+### Code Review
+
+* After finishing, review code. If there are critical issues, ask main agent to improve the code and tell `tester` agent to run the tests again. Repeat the process until all tests pass.
+* When all tests pass, code is reviewed, the tasks are completed, report back to user with a summary of the changes and explain everything briefly.
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+### Documentation
+
+* update the docs if needed.
+  * Create/update `./docs/README.md` file (keep it concise and under 300 lines).
+  * Create/update `./docs/project-overview.-pdr.md` (Product Development Requirements) file.
+  * Create/update `./` file.
+  * Create/update `./docs/system-architecture.md` file.
+  * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+* create a project roadmap at `./docs/project-roadmap.md` file.
+
+### Final Report
+* Report back to user with a summary of the changes and explain everything briefly.
+* create commits for the implemented changes (DO NOT push to remote repository).
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+
+### Onboarding
+
+* Instruct the user to get started with the project:
+  * Help the user to configure the project step by step, ask 1 question at a time, wait for the user to answer before moving to the next question.
+  * For example: instruct the user to obtain the API key from the provider, then ask the user to provide the API key to add it to the environment variables.
+* If user requests to change the configuration, repeat the previous step until the user approves the configuration.