winter-super-cli 2026.5.15

package/resources/local/karpathy-tools/CLAUDE.md

@@ -0,0 +1,65 @@
+# CLAUDE.md
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 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]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**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.

package/resources/local/karpathy-tools/karpathy-md.js

@@ -0,0 +1,140 @@
+/**
+ * karpathy-md.js - Apply Karpathy-style coding guidelines to projects
+ * Usage: node karpathy-md.js <command> [args]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Colors
+const C = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+};
+
+const log = (text, color = 'reset') => console.log(`${C[color]}${text}${C.reset}`);
+
+// Source templates
+const TEMPLATES_DIR = path.join(process.env.HOME || '', 'andrej-karpathy-skills');
+const TOOLS_DIR = path.join(process.env.HOME || '', 'karpathy-tools');
+
+// Check if template exists
+function hasTemplate(name) {
+  return fs.existsSync(path.join(TEMPLATES_DIR, name));
+}
+
+// Commands
+const cmd = process.argv[2];
+const arg = process.argv[3];
+
+switch (cmd) {
+  case 'init':
+  case 'add': {
+    const target = path.join(process.cwd(), 'CLAUDE.md');
+    const source = path.join(TEMPLATES_DIR, 'CLAUDE.md');
+
+    if (fs.existsSync(target)) {
+      log(`⚠️  CLAUDE.md already exists`, 'yellow');
+      log('Options: karpathy-md merge (to append)', 'dim');
+      break;
+    }
+
+    if (!fs.existsSync(source)) {
+      log(`❌ Source template not found`, 'red');
+      break;
+    }
+
+    fs.copyFileSync(source, target);
+    log(`✅ Added CLAUDE.md with Karpathy guidelines`, 'green');
+    break;
+  }
+
+  case 'merge':
+  case 'append': {
+    const target = path.join(process.cwd(), 'CLAUDE.md');
+    const source = path.join(TEMPLATES_DIR, 'CLAUDE.md');
+
+    if (!fs.existsSync(target)) {
+      log(`❌ No CLAUDE.md found in current directory`, 'yellow');
+      log('Run: karpathy-md init', 'dim');
+      break;
+    }
+
+    if (!fs.existsSync(source)) {
+      log(`❌ Source template not found`, 'red');
+      break;
+    }
+
+    const existing = fs.readFileSync(target, 'utf8');
+    const toAppend = fs.readFileSync(source, 'utf8');
+
+    // Append under header
+    fs.writeFileSync(target, existing + '\n\n---\n\n' + toAppend);
+    log(`✅ Merged Karpathy guidelines into existing CLAUDE.md`, 'green');
+    break;
+  }
+
+  case 'view':
+  case 'show':
+    if (hasTemplate('CLAUDE.md')) {
+      console.log(fs.readFileSync(path.join(TEMPLATES_DIR, 'CLAUDE.md'), 'utf8'));
+    } else {
+      log(`❌ Template not found`, 'red');
+    }
+    break;
+
+  case 'examples':
+    if (hasTemplate('EXAMPLES.md')) {
+      console.log(fs.readFileSync(path.join(TEMPLATES_DIR, 'EXAMPLES.md'), 'utf8'));
+    } else {
+      log(`❌ Examples file not found`, 'red');
+    }
+    break;
+
+  case 'rules':
+    log(`\n📋 The 4 Karpathy Rules:\n`, 'cyan');
+    console.log(`
+${C.yellow}1. Think Before Coding${C.reset}
+   • State assumptions explicitly
+   • Ask when uncertain - don't guess
+   • Present multiple interpretations
+
+${C.yellow}2. Simplicity First${C.reset}
+   • No speculative features
+   • No over-engineering
+   • If 200 lines could be 50, rewrite
+
+${C.yellow}3. Surgical Changes${C.reset}
+   • Touch only what's needed
+   • Don't "improve" unrelated code
+   • Match existing style
+
+${C.yellow}4. Goal-Driven Execution${C.reset}
+   • Define success criteria first
+   • Write tests to verify
+   • Loop until goals are met
+`);
+    break;
+
+  default:
+    console.log(`
+${C.cyan}karpathy-md${C.reset} - Apply Karpathy-style coding guidelines
+
+${C.yellow}Commands:${C.reset}
+  init     Add CLAUDE.md to current project
+  merge    Append guidelines to existing CLAUDE.md
+  view     Show the guidelines
+  examples Show practical examples
+  rules    Show the 4 rules summary
+
+${C.yellow}Examples:${C.reset}
+  cd my-project && karpathy-md init
+  karpathy-md view
+  karpathy-md rules
+`);
+}

package/resources/local/manifest.json

@@ -0,0 +1,57 @@
+{
+    "generatedAt":  "2026-05-14T18:37:11.5585557+07:00",
+    "root":  "E:\\dev\\app\\winter\\resources\\local",
+    "localResources":  [
+                           {
+                               "name":  "agents.md",
+                               "path":  "E:\\dev\\app\\winter\\resources\\local\\agents.md",
+                               "files":  90,
+                               "bytes":  2546038
+                           },
+                           {
+                               "name":  "awesome-design-md",
+                               "path":  "E:\\dev\\app\\winter\\resources\\local\\awesome-design-md",
+                               "files":  142,
+                               "bytes":  1912402
+                           },
+                           {
+                               "name":  "claude",
+                               "path":  "E:\\dev\\app\\winter\\resources\\local\\claude",
+                               "files":  971,
+                               "bytes":  17626519
+                           },
+                           {
+                               "name":  "codex",
+                               "path":  "E:\\dev\\app\\winter\\resources\\local\\codex",
+                               "files":  259,
+                               "bytes":  3425257
+                           },
+                           {
+                               "name":  "karpathy-tools",
+                               "path":  "E:\\dev\\app\\winter\\resources\\local\\karpathy-tools",
+                               "files":  2,
+                               "bytes":  6068
+                           },
+                           {
+                               "name":  "manifest.json",
+                               "path":  "E:\\dev\\app\\winter\\resources\\local\\manifest.json",
+                               "files":  1,
+                               "bytes":  2936
+                           }
+                       ],
+    "excludedForSafety":  [
+                              "C:\\Users\\PHUCANSOLUTIONS\\.codex\\auth.json",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.codex\\sessions",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.codex\\history.jsonl",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.codex\\*.sqlite*",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.codex\\log and tmp/cache runtime folders",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.claude\\history.jsonl",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.claude\\sessions",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.claude\\projects",
+                              "C:\\Users\\PHUCANSOLUTIONS\\.claude\\plugins\\cache",
+                              "runtime logs, tmp, cache, auth, local settings, and session state"
+                          ],
+    "redacted":  [
+                     "resources/local/claude/settings.json: ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN"
+                 ]
+}

package/rules/default.md

@@ -0,0 +1,107 @@
+# ❄️ WINTER RULES
+# Coding and development guidelines
+
+## Security Rules
+
+### Command Allowlisting
+- Allowed commands: `git`, `npm`, `node`, `python`, `code`, `pnpm`, `yarn`, `bun`
+- Blocked: Dangerous commands like `rm -rf`, `format`, `del /f /s`
+- Always check command safety before execution
+
+### Path Restrictions
+- Blocked paths: Secrets directories, system directories
+- Allowed: Project directories, temp directories
+
+## Coding Principles
+
+### Think Before Coding
+- State assumptions explicitly
+- Ask clarifying questions when unclear
+- Present tradeoffs if multiple approaches exist
+
+### Simplicity First
+- Minimum code that solves the problem
+- No speculative features
+- If 200 lines could be 50, rewrite it
+
+### Surgical Changes
+- Touch only what you must
+- Match existing code style
+- Clean up only your own mess
+
+## Resource Usage
+
+### Local Resources
+AI có quyền truy cập và tự động sử dụng các tài nguyên cục bộ khi cần thiết để giải quyết tác vụ:
+- **Claude Resources**: `resources/local/claude`
+- **Codex Resources**: `resources/local/codex`
+
+Khi người dùng yêu cầu các tính năng nâng cao, phân tích hệ thống hoặc cần tham khảo các kỹ năng (skills) mẫu, AI nên chủ động tìm kiếm và đọc nội dung trong các thư mục này.
+
+## Goal-Driven Execution
+- Define success criteria
+- Write tests to verify
+- Loop until verified
+
+## Session Management
+
+### Session Commands
+- `/session new` - Create new session
+- `/session save` - Save current session
+- `/session list` - List sessions
+- `/remember <text>` - Add to memory
+
+### Memory Types
+- Working Memory - Current task context
+- Project Memory - Project-specific knowledge
+- Long-term Memory - Cross-project learnings
+
+## Project Detection
+
+### Auto-detect Project
+Check for these files in order:
+1. `CLAUDE.md` - Main project guidelines
+2. `WINTER.md` - Winter-specific guidelines
+3. `.claude/CLAUDE.md` - Claude Code guidelines
+4. `AGENTS.md` - Agent guidelines
+5. `package.json` - Node.js project
+6. `pyproject.toml` - Python project
+7. `Cargo.toml` - Rust project
+
+## Tool Usage
+
+### When to Call Tools
+- **Read**: When asked about code, need to understand structure
+- **Write**: When creating new files
+- **Edit**: When modifying existing files (surgical)
+- **Bash**: When running commands, scripts, git operations
+- **Glob**: When finding files by pattern
+- **Grep**: When searching code content
+
+### Tool Guidelines
+- Call tools proactively - don't just describe, DO
+- Prefer Read over describing code
+- Use Edit for small changes, Write for new files
+- Verify changes after execution
+
+## Design Integration
+
+### Design Systems
+- Integrate with awesome-design-md
+- `winter design search <brand>` - Search brands
+- `winter design add <brand>` - Add design file
+- `winter design preview <brand>` - Preview design
+
+## Performance
+
+### Optimization
+- Use small/fast model for simple tasks
+- Cache responses when appropriate
+- Batch similar operations
+
+## Error Handling
+
+### Error Recovery
+- Log errors clearly
+- Suggest fixes
+- Retry with different approach if needed

package/skills/coding.md

@@ -0,0 +1,87 @@
+# ❄️ Coding Skill
+
+Expert-level coding assistance with automatic tool usage.
+
+## When to Use
+
+Use this skill when the user asks to:
+- Write code, create files
+- Fix bugs
+- Refactor code
+- Understand existing code
+- Review code
+- Add features
+
+## How to Use
+
+### Step 1: Understand the Task
+1. Read relevant project files to understand context
+2. Check for CLAUDE.md, WINTER.md, or other guidelines
+3. Identify the scope of changes needed
+
+### Step 2: Plan Changes
+For simple tasks:
+- Just do it
+
+For complex tasks:
+```
+1. [Action] → verify: [check]
+2. [Action] → verify: [check]
+```
+
+### Step 3: Execute
+- Read files before modifying
+- Use Write for new files
+- Use Edit for existing files (surgical changes)
+- Use Bash for running commands, git, tests
+- Use Glob/Grep to find relevant files
+
+### Step 4: Verify
+- Run tests if available
+- Check the changes work
+- Report what was done
+
+## Examples
+
+### Write New File
+```
+User: Create a REST API for users
+→ Write users.js with Express routes
+→ Test with curl
+```
+
+### Fix Bug
+```
+User: Fix the login bug
+→ Read auth.js to understand the issue
+→ Edit the buggy line
+→ Test the fix
+```
+
+### Understand Code
+```
+User: How does this module work?
+→ Read the module files
+→ Summarize functionality
+```
+
+## Key Principles
+
+1. **Don't assume** - Read code to understand before modifying
+2. **Be surgical** - Only change what's needed
+3. **Verify** - Test your changes work
+4. **Be proactive** - Call tools automatically, don't wait to be asked
+
+## Anti-Patterns
+
+❌ "Here's the code you need:" (describe without writing)
+✅ Write the file directly
+
+❌ "I think you should..." (assume without reading)
+✅ Read the relevant files first
+
+❌ Change 500 lines for a 5-line fix
+✅ Surgical edit only
+
+❌ "Try this and let me know if it works"
+✅ Run tests, verify, report results

package/skills/debug.md

@@ -0,0 +1,63 @@
+# ❄️ Debug Skill
+
+Systematic debugging with automatic tool usage.
+
+## Debugging Process
+
+### 1. Reproduce
+- Run the code to see the error
+- Note the exact error message
+- Identify when it happens
+
+### 2. Understand
+- Read the relevant code
+- Trace the execution flow
+- Identify the root cause
+
+### 3. Fix
+- Make surgical changes
+- Don't over-engineer the fix
+
+### 4. Verify
+- Run the code again
+- Confirm the bug is fixed
+- Check for regressions
+
+## Examples
+
+### Bug: TypeError: Cannot read property 'x' of undefined
+
+```
+1. Reproduce → Run code, see error
+2. Read file with error
+3. Edit: Add null check or fix data source
+4. Verify → Run again
+```
+
+### Bug: API returns 500
+
+```
+1. Reproduce → Call API, see 500
+2. Read server logs (Bash: cat logs)
+3. Read handler code
+4. Fix the issue
+5. Verify → Call API again
+```
+
+## Key Commands
+
+- `Read` - Read source files
+- `Bash` - Run commands, check logs
+- `Edit` - Fix the bug
+- `Grep` - Find related code
+
+## Anti-Patterns
+
+❌ Blind guessing
+✅ Reproduce first, then fix
+
+❌ Over-engineered fixes
+✅ Surgical changes
+
+❌ "It might be..." without evidence
+✅ Read code, trace execution

package/skills/test.md

@@ -0,0 +1,64 @@
+# ❄️ Test Skill
+
+Test generation and execution.
+
+## Test Types
+
+### Unit Tests
+- Test individual functions
+- Mock dependencies
+- Fast to run
+
+### Integration Tests
+- Test API endpoints
+- Test database operations
+- Slower but comprehensive
+
+### E2E Tests
+- Test full user flows
+- Use browser automation
+- Slowest but most realistic
+
+## Process
+
+### 1. Identify What to Test
+- Find the code to test
+- Identify edge cases
+- Check existing tests
+
+### 2. Write Tests
+- Use appropriate framework (Vitest, Jest, etc.)
+- Follow project conventions
+- Cover happy path AND edge cases
+
+### 3. Run Tests
+```bash
+npm test
+# or
+npm run test:watch
+```
+
+### 4. Verify
+- All tests pass
+- Coverage improved
+- No regressions
+
+## Examples
+
+### Add Tests for Function
+```
+User: Add tests for calculateTotal
+→ Read calculateTotal function
+→ Write tests for:
+  - Normal case
+  - Empty array
+  - Negative values
+→ Run tests
+→ Report coverage
+```
+
+## Key Commands
+
+- `Read` - Read source and existing tests
+- `Write` - Create test files
+- `Bash` - Run test commands