winter-super-cli 2026.6.20 → 2026.6.22

package/resources/local/awesome-design-md/design-md-cli.js

@@ -0,0 +1,167 @@
+/**
+ * design-md-cli.js - Interactive CLI for awesome-design-md
+ * Usage: node design-md-cli.js <command> [args]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const DESIGN_MD_DIR = path.join(__dirname, 'design-md');
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+};
+
+function log(text, color = 'reset') {
+  console.log(`${colors[color]}${text}${colors.reset}`);
+}
+
+function readDesignFile(brand) {
+  const dir = path.join(DESIGN_MD_DIR, brand);
+  if (fs.existsSync(path.join(dir, 'DESIGN.md'))) {
+    return { file: 'DESIGN.md', content: fs.readFileSync(path.join(dir, 'DESIGN.md'), 'utf8') };
+  }
+  if (fs.existsSync(path.join(dir, 'README.md'))) {
+    return { file: 'README.md', content: fs.readFileSync(path.join(dir, 'README.md'), 'utf8') };
+  }
+  return null;
+}
+
+function search(query) {
+  const brands = fs.readdirSync(DESIGN_MD_DIR).filter(f =>
+    fs.statSync(path.join(DESIGN_MD_DIR, f)).isDirectory()
+  );
+
+  const matches = brands.filter(b => b.toLowerCase().includes(query.toLowerCase()));
+
+  if (matches.length === 0) {
+    log(`❌ No matches for "${query}"`, 'yellow');
+    return;
+  }
+
+  log(`\n🔍 Results for "${query}" (${matches.length}):\n`, 'cyan');
+  matches.forEach((brand, i) => {
+    const data = readDesignFile(brand);
+    const size = data ? Math.round(data.content.length / 1024) : 0;
+    log(`  ${i + 1}. ${brand} ${colors.dim}(~${size}KB)${colors.reset}`);
+  });
+  console.log();
+}
+
+function addToProject(brand) {
+  const data = readDesignFile(brand);
+
+  if (!data) {
+    log(`❌ Brand "${brand}" not found`, 'yellow');
+    log('Run: node design-md-cli.js list', 'dim');
+    return false;
+  }
+
+  const targetPath = path.join(process.cwd(), data.file);
+
+  if (fs.existsSync(targetPath)) {
+    log(`⚠️  ${data.file} already exists`, 'yellow');
+    return false;
+  }
+
+  fs.writeFileSync(targetPath, data.content);
+  log(`✅ Added ${data.file} for ${brand}`, 'green');
+  return true;
+}
+
+function preview(brand) {
+  const data = readDesignFile(brand);
+
+  if (!data) {
+    log(`❌ Brand "${brand}" not found`, 'yellow');
+    return;
+  }
+
+  console.log('\n' + '='.repeat(60));
+  log(`📋 ${brand} - ${data.file}`, 'cyan');
+  console.log('='.repeat(60) + '\n');
+
+  // Show first 50 lines
+  const lines = data.content.split('\n').slice(0, 50);
+  console.log(lines.join('\n'));
+  console.log(colors.dim + '\n... (truncated)' + colors.reset);
+}
+
+function list() {
+  const brands = fs.readdirSync(DESIGN_MD_DIR).filter(f =>
+    fs.statSync(path.join(DESIGN_MD_DIR, f)).isDirectory()
+  ).sort();
+
+  log(`\n📦 Available brands: ${brands.length}\n`, 'cyan');
+
+  // Group by first letter
+  const grouped = {};
+  brands.forEach(b => {
+    const letter = b[0].toUpperCase();
+    if (!grouped[letter]) grouped[letter] = [];
+    grouped[letter].push(b);
+  });
+
+  Object.keys(grouped).sort().forEach(letter => {
+    console.log(`\n${colors.yellow}[${letter}]${colors.reset}`);
+    grouped[letter].forEach(b => {
+      const data = readDesignFile(b);
+      const size = data ? Math.round(data.content.length / 1024) : 0;
+      console.log(`  ${b.padEnd(15)} ${colors.dim}${size}KB${colors.reset}`);
+    });
+  });
+  console.log();
+}
+
+// Main CLI
+const cmd = process.argv[2];
+const arg = process.argv[3];
+
+switch (cmd) {
+  case 'search':
+  case 'find':
+    search(arg || '');
+    break;
+
+  case 'add':
+    addToProject(arg);
+    break;
+
+  case 'preview':
+  case 'view':
+    preview(arg);
+    break;
+
+  case 'list':
+    list();
+    break;
+
+  case 'init':
+    fs.mkdirSync('.design-systems', { recursive: true });
+    log('✅ Created .design-systems/', 'green');
+    break;
+
+  default:
+    console.log(`
+${colors.cyan}design-md CLI${colors.reset} - Search and add DESIGN.md files
+
+${colors.yellow}Commands:${colors.reset}
+  search <name>  Search for a brand
+  add <brand>    Add design file to project
+  preview <brand> Preview design file
+  list           List all brands
+  init           Create .design-systems/ dir
+
+${colors.yellow}Examples:${colors.reset}
+  node design-md-cli.js search stripe
+  node design-md-cli.js add vercel
+  node design-md-cli.js preview figma
+`);
+}

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/scripts/audit-pack.js

@@ -34,6 +34,19 @@ const violations = files
     blockedPatterns.some(pattern => pattern.test(filePath))
   ));
 
+const requiredPrefixes = [
+  'resources/local/agents.md/',
+  'resources/local/awesome-design-md/',
+  'resources/local/karpathy-tools/',
+  'resources/local/page-agent/',
+  'resources/local/ecc/',
+  'skills/',
+  'memories/',
+];
+
+const missingRequired = requiredPrefixes
+  .filter(prefix => !files.some(file => file.path.startsWith(prefix)));
+
 if (violations.length > 0) {
   console.error('Package audit failed. Blocked files would be published:');
   for (const filePath of violations.slice(0, 50)) {
@@ -45,4 +58,12 @@ if (violations.length > 0) {
   process.exit(1);
 }
 
+if (missingRequired.length > 0) {
+  console.error('Package audit failed. Required packaged paths are missing:');
+  for (const prefix of missingRequired) {
+    console.error(`- ${prefix}`);
+  }
+  process.exit(1);
+}
+
 console.log(`Package audit passed: ${files.length} files, ${(pack.size / 1024 / 1024).toFixed(2)} MB tgz, ${(pack.unpackedSize / 1024 / 1024).toFixed(2)} MB unpacked.`);

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

package/src/cli/tool-call-adapter.js

@@ -39,8 +39,14 @@ export function extractInlineToolCalls(content, idFactory = index => `inline-${D
   };
   const pushParsedToolObject = (parsed) => {
     const { name, args } = extractToolPayload(parsed, parseToolArguments);
-    if (!name || typeof name !== 'string') return false;
-    pushToolCall(name, args, 'object');
+    if (name && typeof name === 'string') {
+      pushToolCall(name, args, 'object');
+      return true;
+    }
+
+    const inferred = inferSafeToolFromBareArguments(parsed);
+    if (!inferred) return false;
+    pushToolCall(inferred.name, inferred.args, 'bare-arguments');
     return true;
   };
 
@@ -304,6 +310,22 @@ function extractToolPayload(payload, parseArguments) {
   };
 }
 
+export function inferSafeToolFromBareArguments(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+
+  const keys = Object.keys(value);
+  if (keys.length === 0) return null;
+
+  const hasGenericPayloadKeys = keys.some(key => /^(arguments?|args?|input|parameters?|params?|tool[_-]?input|function[_-]?arguments?)$/i.test(key));
+  if (!hasGenericPayloadKeys) return null;
+
+  const name = value.name || value.tool || value.tool_name || value.function_name || null;
+  if (typeof name !== 'string' || !name.trim()) return null;
+
+  const args = value.arguments ?? value.args ?? value.input ?? value.parameters ?? value.params ?? value.tool_input ?? value.function_arguments ?? {};
+  return { name, args };
+}
+
 export function formatToolCallsForMessage(toolCalls) {
   return toolCalls.map((tc) => ({
     id: tc.id,