winter-super-cli 2026.5.15

package/CLAUDE.md

@@ -0,0 +1,118 @@
+# ❄️ WINTER CLAUDE.md
+
+Behavioral guidelines for Winter CLI. These principles should be followed in every interaction.
+
+## The Four Principles
+
+### 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them — don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+### 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked
+- No abstractions for single-use code
+- No "flexibility" or "configurability" that wasn't requested
+- No error handling for impossible scenarios
+- If you write 200 lines and it could be 50, rewrite it
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+### 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting
+- Don't refactor things that aren't broken
+- Match existing style, even if you'd do it differently
+- If you notice unrelated dead code, mention it — don't delete it
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused
+- Don't remove pre-existing dead code unless asked
+
+**The test:** Every changed line should trace directly to the user's request.
+
+### 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+## Session Management
+
+### Session Commands
+- `/session new` - Create new session
+- `/session save` - Save current session
+- `/session list` - List sessions
+- `/remember <text>` - Add to memory
+
+### Memory System
+- Working Memory - Current task context
+- Project Memory - Project-specific knowledge
+- Long-term Memory - Cross-project learnings
+
+## AI Provider Integration
+
+### Supported Providers
+- **Anthropic** - claude-3-5-sonnet, claude-3-opus (default)
+- **OpenAI** - gpt-4, gpt-4-turbo, gpt-3.5-turbo
+- **Ollama** - llama3, mistral, codellama (local)
+- **Groq** - llama-3.1-70b, mixtral-8x7b
+
+### Usage
+```bash
+winter chat "Your message" --provider anthropic
+winter call "Analyze this"  # Call all providers
+```
+
+## Skills System
+
+Built-in skills:
+- `coding` - Code analysis, generation, review
+- `design` - Design system integration
+- `debug` - Debugging assistance
+- `refactor` - Code refactoring
+- `test` - Test generation
+
+Custom skills via `winter skill create <name>`.
+
+## Design Integration
+
+Access brand design guidelines from awesome-design-md:
+```bash
+winter design search <brand>
+winter design add <brand>
+winter design preview <brand>
+```
+
+## Key Insight
+
+> "LLMs are exceptionally good at looping until they meet specific goals... Don't tell it what to do, give it success criteria and watch it go."
+
+Transform imperative instructions into declarative goals with verification loops.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.

package/README.md

@@ -0,0 +1,81 @@
+# Winter - Advanced AI Coding Assistant / Tro ly Lap trinh AI Nang cao
+
+Winter is a powerful, AI-driven CLI coding assistant designed to supercharge your development workflow directly from the terminal. Inspired by state-of-the-art tools like Claude Code, Winter brings a beautiful Cyberpunk aesthetic, smart session management, and autonomous agent capabilities to your local environment.
+
+*Winter la mot tro ly lap trinh CLI manh me duoc dieu khien boi AI, duoc thiet ke de tang toc quy trinh phat trien cua ban truc tiep tu terminal. Lay cam hung tu cac cong cu hang dau nhu Claude Code, Winter mang den giao dien Cyberpunk dep mat, quan ly phien lam viec thong minh va kha nang chay agent tu tri vao moi truong cuc bo cua ban.*
+
+
+## Key Features / Tinh nang noi bat
+
+- **Immersive Cyberpunk CLI**: Stunning ASCII art banner and intuitive terminal interface.
+  *(Giao dien Cyberpunk: Banner ASCII dep mat va giao dien terminal truc quan.)*
+- **Smart Session Management**: Isolated sessions with memory persistence. Resume any session anytime.
+  *(Quan ly phien thong minh: Cac phien lam viec doc lap voi bo nho duoc luu tru. Tiep tuc bat ky phien nao bat cu luc nao.)*
+- **Auto-Context Loading**: Automatically reads project rules from winter.md and system resources on startup.
+  *(Tu dong nap ngu canh: Tu dong doc cac quy tac du an tu winter.md va tai nguyen he thong khi khoi dong.)*
+- **Autonomous Agents**: Built-in Browser Subagent for web searching and complex task solving.
+  *(Agent tu tri: Tich hop Browser Subagent de tim kiem web va giai quyet cac tac vu phuc tap.)*
+- **Git Auto-Pilot**: Automatic commit message generation and AI-powered code reviews.
+  *(Tu dong hoa Git: Tu dong tao commit message va review code bang AI.)*
+- **Auto-Healing Mode**: TDD-style loop where AI runs tests and automatically fixes errors until success.
+  *(Che do Tu sua loi: Vong lap kieu TDD noi AI chay test va tu dong sua loi cho den khi thanh cong.)*
+
+## Installation / Cai dat
+
+To install Winter globally in your system, clone the repository and run:
+*De cai dat Winter tren toan he thong, hay clone repository va chay:*
+
+```bash
+npm install -g .
+```
+
+*(Or run directly without installation using node bin/winter.js)*
+*(Hoac chay truc tiep khong can cai dat bang lenh node bin/winter.js)*
+
+## Getting Started / Huong dan su dung
+
+To start a new session in your current project directory:
+*De bat dau mot phien lam viec moi trong thu muc du an hien tai:*
+
+```bash
+winter
+```
+
+To resume a specific session later:
+*De tiep tuc mot phien lam viec cu the sau nay:*
+
+```bash
+winter --session <session-id>
+```
+
+## Project Rules (winter.md) / Quy tac du an
+
+When you start Winter in a new project, it will automatically generate a winter.md file at the root. You can customize this file to define specific rules, tech stacks, and guidelines for the AI to follow in that specific project.
+
+*Khi ban khoi dong Winter trong mot du an moi, no se tu dong tao file winter.md o thu muc goc. Ban co the tuy chinh file nay de dinh nghia cac quy tac, cong nghe su dung va huong dan cho AI tuan theo trong du an do.*
+
+## Slash Commands / Cac lenh Slash
+
+While in the REPL, you can use the following commands:
+*Khi dang trong giao dien REPL, ban co the su dung cac lenh sau:*
+
+- `/help` - Show all available commands. *(Hien thi tat ca cac lenh.)*
+- `/clear` - Clear the terminal screen. *(Xoa man hinh terminal.)*
+- `/commit` - Automatically generate a commit message and commit staged changes. *(Tu dong tao commit message va commit.)*
+- `/review` - AI reviews your current git diff for bugs and clean code. *(AI review cac thay doi git hien tai.)*
+- `/auto <task>` - Run a task in Auto-Healing mode. *(Chay tac vu trong che do tu sua loi.)*
+- `/agent browser "<prompt>"` - Trigger the browser subagent to browse the web. *(Kich hoat agent duyet web.)*
+- `/plans` - View or manage active execution plans. *(Xem hoac quan ly cac ke hoach thuc thi.)*
+- `/forget` - Clear the current session memory. *(Xoa bo nho cua phien hien tai.)*
+
+## Core Philosophy / Triet ly cot loi
+
+Winter operates on three core principles:
+*Winter hoat dong dua tren ba nguyen tac cot loi:*
+
+1. **Think Before Coding**: Explicit assumptions, push back on ambiguity. *(Nghi truoc khi code: Neu ro cac gia dinh, lam ro cac diem mo ho.)*
+2. **Simplicity First**: Minimum code to solve the problem, no over-engineering. *(Don gian la tren het: Viet luong code toi thieu de giai quyet van de, khong ve them viec.)*
+3. **Surgical Changes**: Touch only what you must, match existing style. *(Sua doi chinh xac: Chi cham vao nhung gi can thiet, tuan thu phong cach code co san.)*
+
+---
+*Built by Atus | fb: iam.anhtu | github: anhtu1707*

package/WINTER.md

@@ -0,0 +1,30 @@
+# Winter Project Rules
+
+## 📝 Project Overview
+- **Name**: [Tên dự án]
+- **Description**: [Mô tả ngắn về dự án]
+
+## 🛠 Tech Stack
+- **Languages**: JavaScript / TypeScript
+- **Runtime**: Node.js
+- **Frameworks**: [Tự điền nếu có, VD: Express, React...]
+
+## 🎯 AI Behavior & Coding Guidelines
+
+### 1. Nguyên Tắc Code (Coding Standards)
+- Luôn ưu tiên viết code sạch (Clean Code), dễ đọc và dễ bảo trì.
+- Sử dụng ES Modules (`import/export`) thay vì CommonJS (`require`) trừ khi có lý do đặc biệt.
+- Giữ nguyên các comment và JSDoc hiện có trong file trừ khi được yêu cầu sửa.
+
+### 2. Tương Tác Với Người Dùng (User Interaction)
+- Luôn giải thích NGẮN GỌN lý do thực hiện thay đổi trước khi sửa file.
+- Khi gặp lỗi, hãy đề xuất giải pháp thay vì chỉ báo lỗi.
+- KHÔNG tự tiện xóa code cũ của user trừ khi chắc chắn nó không còn dùng hoặc được yêu cầu.
+
+### 3. Git & Commits
+- Viết commit message theo chuẩn Conventional Commits (VD: `feat:`, `fix:`, `docs:`).
+- Luôn kiểm tra `git status` trước khi thực hiện thay đổi lớn.
+
+### 4. Xử Lý File (File Operations)
+- Chỉ sửa những dòng cần thiết, tránh viết lại toàn bộ file nếu không cần.
+- Luôn đảm bảo file không bị lỗi cú pháp sau khi sửa.

package/bin/winter.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * ❄️ WINTER CLI ❄️
+ * Build by Atus fb: iam.anhtu, github: anhtu1707 with Interactive REPL
+ */
+
+import { WinterREPL } from '../src/cli/repl.js';
+import { ConfigLoader } from '../src/cli/config.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync } from 'fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const version = pkg.version;
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Parse commands
+  if (args.length === 0 || args.includes('i') || args.includes('interactive') || args.includes('--session')) {
+    // Start interactive REPL mode
+    const config = new ConfigLoader();
+    const cfg = await config.load();
+    
+    let projectPath = process.cwd();
+    let sessionId = null;
+
+    const sessionIndex = args.indexOf('--session');
+    if (sessionIndex !== -1 && args[sessionIndex + 1]) {
+      sessionId = args[sessionIndex + 1];
+    }
+
+    // Lấy projectPath từ tham số không phải cờ (nếu có)
+    const nonFlagArgs = args.filter(a => !a.startsWith('-') && a !== 'i' && a !== 'interactive' && a !== sessionId);
+    if (nonFlagArgs[0]) {
+      projectPath = path.resolve(nonFlagArgs[0]);
+    }
+
+    const repl = new WinterREPL({ projectPath, sessionId, version });
+    await repl.start();
+    return;
+  }
+
+  // Handle commands
+  const [command, ...rest] = args;
+
+  switch (command) {
+    case 'chat':
+      await handleChatWithTools(rest);
+      break;
+    case 'call':
+      await handleCallAll(rest);
+      break;
+    case 'session':
+      await handleSession(rest);
+      break;
+    case 'skill':
+      await handleSkill(rest);
+      break;
+    case 'plugin':
+      await handlePlugin(rest);
+      break;
+    case 'design':
+      await handleDesign(rest);
+      break;
+    case 'config':
+      await handleConfig(rest);
+      break;
+    case 'init':
+      await handleInit(rest);
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      break;
+    case '--version':
+    case '-v':
+      console.log(`❄️ Winter CLI v${version}\n`);
+      break;
+    default: {
+      // If no recognized command, treat the full input as a prompt.
+      const config = new ConfigLoader();
+      const cfg = await config.load();
+      const repl = new WinterREPL({ projectPath: cfg.project?.current || process.cwd() });
+      await repl.session.init();
+      await repl.ai.init();
+      await repl.chat([command, ...rest].join(' '));
+      break;
+    }
+  }
+}
+
+async function handleChatWithTools(args) {
+  const config = new ConfigLoader();
+  const message = args.join(' ');
+  if (!message) {
+    console.log('Usage: winter chat <message>');
+    return;
+  }
+
+  try {
+    const cfg = await config.load();
+    const repl = new WinterREPL({ projectPath: cfg.project?.current || process.cwd() });
+    await repl.session.init();
+    await repl.ai.init();
+    await repl.chat(message);
+  } catch (error) {
+    console.error(`\nWinter error: ${error.message}\n`);
+  }
+}
+
+async function handleCallAll(args) {
+  const { AIProviderManager } = await import('../src/ai/providers.js');
+  const config = new ConfigLoader();
+  const prompt = args.join(' ');
+
+  if (!prompt) {
+    console.log('Usage: winter call <prompt>');
+    return;
+  }
+
+  const ai = new AIProviderManager(config);
+  const results = await ai.callAllProviders(prompt);
+
+  for (const [provider, result] of Object.entries(results)) {
+    if (result.error) {
+      console.log(`\n[${provider}] ERROR\n${result.error}`);
+    } else {
+      console.log(`\n[${provider}] ${result.model}\n${result.content}`);
+    }
+  }
+}
+
+async function handleSession(args) {
+  const { SessionManager } = await import('../src/session/manager.js');
+  const config = new ConfigLoader();
+  const session = new SessionManager(config);
+  await session.init();
+
+  const [action, ...rest] = args;
+
+  switch (action) {
+    case 'new':
+      const s = await session.newSession();
+      console.log(`✓ New session: ${s.id.substring(0, 8)}`);
+      break;
+    case 'list':
+      const sessions = await session.listSessions();
+      console.log(`\nSessions:`);
+      sessions.forEach(s => console.log(`  ${s.id.substring(0, 8)} - ${s.createdAt}`));
+      break;
+    default:
+      console.log(`Session: ${session.getSessionId().substring(0, 8)}`);
+  }
+}
+
+async function handleSkill(args) {
+  const { SkillManager } = await import('../src/skills/manager.js');
+  const config = new ConfigLoader();
+  const session = new SessionManager(config);
+  await session.init();
+
+  const skills = new SkillManager(session);
+  const list = await skills.listSkills();
+
+  console.log(`\n❄️ Available Skills:`);
+  list.forEach(s => console.log(`  ${s.icon} ${s.name} - ${s.description}`));
+  console.log('');
+}
+
+async function handlePlugin(args) {
+  const { PluginManager } = await import('../src/plugins/manager.js');
+  const session = new SessionManager({});
+  const plugins = new PluginManager(session);
+  const list = await plugins.listPlugins();
+
+  console.log(`\n❄️ Installed Plugins:`);
+  list.forEach(p => console.log(`  ${p.icon} ${p.name} v${p.version}`));
+  console.log('');
+}
+
+async function handleDesign(args) {
+  const { DesignCommands } = await import('../src/design/commands.js');
+  const config = new ConfigLoader();
+  const session = new SessionManager(config);
+  await session.init();
+
+  const design = new DesignCommands(session, config);
+  await design.execute(args[0], args.slice(1));
+}
+
+async function handleConfig(args) {
+  const config = new ConfigLoader();
+  const cfg = await config.load();
+  console.log(`\n❄️ Configuration:\n`);
+  console.log(JSON.stringify(cfg, null, 2));
+  console.log('');
+}
+
+async function handleInit(args) {
+  console.log('❄️ Initializing Winter CLI...');
+  // Create necessary directories and files
+  console.log('✓ Ready!');
+}
+
+function printHelp() {
+  console.log(`
+WINTER CLI
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Commands:
+
+  winter                 Start interactive REPL
+  winter i               Interactive mode
+  winter chat <msg>      Chat with AI
+  winter call <prompt>   Call all configured providers
+  winter session         Session management
+  winter skill           List skills
+  winter plugin          List plugins
+  winter design          Design commands
+  winter config          Show config
+
+Important REPL slash commands:
+
+  /provider <name>       Switch provider and save default
+  /model <model-id>      Set model for active provider
+  /models                List configured and cached models
+  /codex [section]       Browse ~/.codex resources
+  /claude [section]      Browse ~/.claude resources
+  /karpathy              Browse ~/karpathy-tools
+  /designs [query]       List/search awesome-design-md systems
+  /agents                Read ~/agents.md
+  /skills                List Winter/Codex/Claude skills
+
+Version ${version}
+  `);
+  return;
+  console.log(`
+❄️ WINTER CLI ❄️
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 Commands:
+
+  winter                 Start interactive REPL (gõ winter)
+  winter i              Interactive mode
+  winter chat <msg>     Chat with AI
+
+  winter session        Session management
+  winter skill         List skills
+  winter plugin        List plugins
+  winter design        Design commands
+  winter config        Show config
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 Just type 'winter' to start chatting with your project!
+
+❄️ Version ${version}
+  `);
+}
+
+main().catch(err => {
+  console.error(`\n❄️ Error: ${err.message}\n`);
+  process.exit(1);
+});
+
+export { main };

package/memories/readme.md

@@ -0,0 +1,35 @@
+# ❄️ Winter Memories
+
+This directory stores cross-project knowledge and learnings.
+
+## Memory Types
+
+### Long-term Memory
+Learned patterns, best practices, and project insights that persist across sessions.
+
+### Project Memory
+Project-specific knowledge including:
+- Project structure
+- Key files and their purposes
+- Common workflows
+- Team conventions
+
+## Commands
+
+- `/remember <text>` - Add a memory
+- `/memories` - Show all memories
+- `/memories search <query>` - Search memories
+- `/forget <pattern>` - Remove memories
+
+## Example Memories
+
+```
+- User prefers TypeScript over JavaScript
+- This project uses React with Vite
+- Database is PostgreSQL
+- API is REST-based
+```
+
+## Storage
+
+Memories are stored as JSON files in this directory, automatically organized by date and topic.

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "winter-super-cli",
+  "version": "2026.5.15",
+  "description": "❄️ AI-Powered Development CLI with Interactive REPL",
+  "type": "module",
+  "main": "bin/winter.js",
+  "bin": {
+    "winter": "bin/winter.js"
+  },
+  "scripts": {
+    "start": "node bin/winter.js",
+    "dev": "node bin/winter.js",
+    "test": "node --test src/**/*.test.js"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "coding",
+    "assistant",
+    "interactive",
+    "repl"
+  ],
+  "author": "Winter CLI",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "cli-highlight": "^2.1.11",
+    "diff": "^9.0.0",
+    "puppeteer": "^24.43.1"
+  }
+}

package/resources/local/agents.md/AGENTS.md

@@ -0,0 +1,43 @@
+# AGENTS Guidelines for This Repository
+
+This repository contains a Next.js application located in the root of this repository. When
+working on the project interactively with an agent (e.g. the Codex CLI) please follow
+the guidelines below so that the development experience – in particular Hot Module
+Replacement (HMR) – continues to work smoothly.
+
+## 1. Use the Development Server, **not** `npm run build`
+
+* **Always use `npm run dev` (or `pnpm dev`, `yarn dev`, etc.)** while iterating on the
+  application.  This starts Next.js in development mode with hot-reload enabled.
+* **Do _not_ run `npm run build` inside the agent session.**  Running the production
+  build command switches the `.next` folder to production assets which disables hot
+  reload and can leave the development server in an inconsistent state.  If a
+  production build is required, do it outside of the interactive agent workflow.
+
+## 2. Keep Dependencies in Sync
+
+If you add or update dependencies remember to:
+
+1. Update the appropriate lockfile (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`).
+2. Re-start the development server so that Next.js picks up the changes.
+
+## 3. Coding Conventions
+
+* Prefer TypeScript (`.tsx`/`.ts`) for new components and utilities.
+* Co-locate component-specific styles in the same folder as the component when
+  practical.
+
+## 4. Useful Commands Recap
+
+| Command            | Purpose                                            |
+| ------------------ | -------------------------------------------------- |
+| `npm run dev`      | Start the Next.js dev server with HMR.             |
+| `npm run lint`     | Run ESLint checks.                                 |
+| `npm run test`     | Execute the test suite (if present).               |
+| `npm run build`    | **Production build – _do not run during agent sessions_** |
+
+---
+
+Following these practices ensures that the agent-assisted development workflow stays
+fast and dependable.  When in doubt, restart the dev server rather than running the
+production build.

package/resources/local/agents.md/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/resources/local/agents.md/README.md

@@ -0,0 +1,49 @@
+# AGENTS.md
+
+![AGENTS.md logo](./public/og.png)
+
+[AGENTS.md](https://agents.md) is a simple, open format for guiding coding agents.
+
+Think of AGENTS.md as a README for agents: a dedicated, predictable place
+to provide context and instructions to help AI coding agents work on your project.
+
+Below is a minimal example of an AGENTS.md file:
+
+```markdown
+# Sample AGENTS.md file
+
+## Dev environment tips
+- Use `pnpm dlx turbo run where <project_name>` to jump to a package instead of scanning with `ls`.
+- Run `pnpm install --filter <project_name>` to add the package to your workspace so Vite, ESLint, and TypeScript can see it.
+- Use `pnpm create vite@latest <project_name> -- --template react-ts` to spin up a new React + Vite package with TypeScript checks ready.
+- Check the name field inside each package's package.json to confirm the right name—skip the top-level one.
+
+## Testing instructions
+- Find the CI plan in the .github/workflows folder.
+- Run `pnpm turbo run test --filter <project_name>` to run every check defined for that package.
+- From the package root you can just call `pnpm test`. The commit should pass all tests before you merge.
+- To focus on one step, add the Vitest pattern: `pnpm vitest run -t "<test name>"`.
+- Fix any test or type errors until the whole suite is green.
+- After moving files or changing imports, run `pnpm lint --filter <project_name>` to be sure ESLint and TypeScript rules still pass.
+- Add or update tests for the code you change, even if nobody asked.
+
+## PR instructions
+- Title format: [<project_name>] <Title>
+- Always run `pnpm lint` and `pnpm test` before committing.
+```
+
+## Website
+
+This repository also includes a basic Next.js website hosted at https://agents.md/
+that explains the project’s goals in a simple way, and featuring some examples.
+
+### Running the app locally
+1. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+2. Start the development server:
+   ```bash
+   pnpm run dev
+   ```
+3. Open your browser and go to http://localhost:3000