claude-brain 0.30.2 → 0.31.1

package/packs/core/javascript.json

@@ -1,176 +1,176 @@
-{
-  "id": "core/javascript",
-  "name": "JavaScript Fundamentals",
-  "version": "1.0.0",
-  "stack": ["javascript"],
-  "description": "Closures, event loop, async patterns, modern ES features, and coercion pitfalls",
-  "author": "claude-brain",
-  "entries": [
-    {
-      "type": "best-practice",
-      "category": "Async Patterns",
-      "title": "Use async/await over raw promises",
-      "content": "Prefer async/await over .then() chains for readability and debuggability. Async/await produces clearer stack traces and is easier to reason about for error handling with try/catch.",
-      "confidence": 0.95,
-      "tags": ["javascript", "async", "promises"]
-    },
-    {
-      "type": "common-issue",
-      "category": "Async Patterns",
-      "title": "Avoid unhandled promise rejections",
-      "content": "Always handle promise rejections with try/catch in async functions or .catch() on promises. Unhandled rejections can crash Node.js processes and cause silent failures in browsers.",
-      "confidence": 0.95,
-      "tags": ["javascript", "async", "error-handling"]
-    },
-    {
-      "type": "anti-pattern",
-      "category": "Async Patterns",
-      "title": "Avoid sequential awaits for independent operations",
-      "content": "Don't await independent async operations sequentially. Use Promise.all() or Promise.allSettled() to run them concurrently. Sequential awaits waste time waiting for operations that could run in parallel.",
-      "confidence": 0.9,
-      "tags": ["javascript", "async", "performance"],
-      "example": "const [users, posts] = await Promise.all([fetchUsers(), fetchPosts()])"
-    },
-    {
-      "type": "best-practice",
-      "category": "Modern ES",
-      "title": "Use destructuring for cleaner code",
-      "content": "Use destructuring assignment for objects and arrays to extract values concisely. This reduces intermediate variables and makes function parameter expectations clearer.",
-      "confidence": 0.9,
-      "tags": ["javascript", "es6", "destructuring"],
-      "example": "const { name, age } = user; const [first, ...rest] = items;"
-    },
-    {
-      "type": "best-practice",
-      "category": "Modern ES",
-      "title": "Prefer const, use let sparingly, avoid var",
-      "content": "Use `const` by default for all bindings. Only use `let` when reassignment is necessary. Never use `var` — it has function scoping and hoisting that causes bugs.",
-      "confidence": 0.95,
-      "tags": ["javascript", "variables", "scoping"]
-    },
-    {
-      "type": "common-issue",
-      "category": "Closures",
-      "title": "Understand closure variable capture",
-      "content": "Closures capture variables by reference, not by value. In loops, use `let` (block-scoped) instead of `var` to ensure each iteration gets its own copy. Arrow functions in loops with `var` all share the same variable.",
-      "confidence": 0.9,
-      "tags": ["javascript", "closures", "scoping"]
-    },
-    {
-      "type": "common-issue",
-      "category": "Event Loop",
-      "title": "Understand microtask vs macrotask ordering",
-      "content": "Promise callbacks (microtasks) run before setTimeout/setInterval callbacks (macrotasks). This matters for operation ordering. process.nextTick runs before all other microtasks in Node.js.",
-      "confidence": 0.85,
-      "tags": ["javascript", "event-loop", "async"]
-    },
-    {
-      "type": "anti-pattern",
-      "category": "Coercion",
-      "title": "Avoid loose equality (==)",
-      "content": "Always use strict equality (===) to avoid JavaScript's type coercion rules. Loose equality has unintuitive results like `'' == 0` being true and `null == undefined` being true.",
-      "confidence": 0.95,
-      "tags": ["javascript", "equality", "coercion"]
-    },
-    {
-      "type": "best-practice",
-      "category": "Modern ES",
-      "title": "Use optional chaining and nullish coalescing",
-      "content": "Use `?.` for safe property access on potentially null/undefined values. Use `??` for default values (only triggers on null/undefined, unlike `||` which triggers on falsy values).",
-      "confidence": 0.9,
-      "tags": ["javascript", "null-safety", "es2020"],
-      "example": "const name = user?.profile?.name ?? 'Anonymous'"
-    },
-    {
-      "type": "pattern",
-      "category": "Error Handling",
-      "title": "Create custom error classes for domain errors",
-      "content": "Extend the Error class for domain-specific errors. Include error codes, HTTP status codes, or other structured data to enable programmatic error handling.",
-      "confidence": 0.85,
-      "tags": ["javascript", "error-handling"],
-      "example": "class NotFoundError extends Error { constructor(resource) { super(`${resource} not found`); this.name = 'NotFoundError'; this.status = 404; } }"
-    },
-    {
-      "type": "best-practice",
-      "category": "Modern ES",
-      "title": "Use spread operator for immutable updates",
-      "content": "Use the spread operator to create shallow copies when updating objects or arrays. This supports immutable patterns without external libraries.",
-      "confidence": 0.9,
-      "tags": ["javascript", "immutability", "spread"],
-      "example": "const updated = { ...user, name: 'New Name' }"
-    },
-    {
-      "type": "common-issue",
-      "category": "Modern ES",
-      "title": "Understand shallow vs deep copy",
-      "content": "Spread and Object.assign only create shallow copies. Nested objects are still references. Use structuredClone() for deep copies, or libraries like immer for complex immutable updates.",
-      "confidence": 0.9,
-      "tags": ["javascript", "immutability", "deep-copy"]
-    },
-    {
-      "type": "anti-pattern",
-      "category": "Functions",
-      "title": "Avoid modifying function arguments",
-      "content": "Don't mutate objects or arrays passed as function arguments. This causes action-at-a-distance bugs. Return new values instead of modifying inputs.",
-      "confidence": 0.85,
-      "tags": ["javascript", "functions", "immutability"]
-    },
-    {
-      "type": "best-practice",
-      "category": "Modules",
-      "title": "Use ES modules (import/export)",
-      "content": "Prefer ES modules over CommonJS require(). ESM enables static analysis, tree-shaking, and top-level await. Most modern tools and runtimes support ESM natively.",
-      "confidence": 0.9,
-      "tags": ["javascript", "modules", "esm"]
-    },
-    {
-      "type": "pattern",
-      "category": "Arrays",
-      "title": "Use array methods for data transformations",
-      "content": "Prefer map, filter, reduce, find, and some over imperative loops for data transformations. They're more declarative, composable, and less error-prone.",
-      "confidence": 0.85,
-      "tags": ["javascript", "arrays", "functional"]
-    },
-    {
-      "type": "common-issue",
-      "category": "Coercion",
-      "title": "Be cautious with truthy/falsy checks",
-      "content": "JavaScript has six falsy values: false, 0, '', null, undefined, NaN. Be explicit when checking for null/undefined vs falsy. `if (value)` will miss 0 and empty string.",
-      "confidence": 0.9,
-      "tags": ["javascript", "coercion", "truthiness"]
-    },
-    {
-      "type": "best-practice",
-      "category": "Modern ES",
-      "title": "Use Map and Set for appropriate data structures",
-      "content": "Use Map instead of plain objects when keys are dynamic or non-string. Use Set for unique collections. Both have better performance characteristics and cleaner APIs than object-based alternatives.",
-      "confidence": 0.85,
-      "tags": ["javascript", "data-structures", "es6"]
-    },
-    {
-      "type": "anti-pattern",
-      "category": "Async Patterns",
-      "title": "Avoid mixing callbacks and promises",
-      "content": "Don't mix callback-style and promise-style async code. Use util.promisify() or write promise wrappers to convert callback APIs. Mixing styles leads to unhandled errors and confusing control flow.",
-      "confidence": 0.9,
-      "tags": ["javascript", "async", "callbacks"]
-    },
-    {
-      "type": "pattern",
-      "category": "Performance",
-      "title": "Use AbortController for cancellable operations",
-      "content": "Use AbortController with AbortSignal for cancellable fetch requests, event listeners, and async operations. This prevents memory leaks from abandoned operations.",
-      "confidence": 0.85,
-      "tags": ["javascript", "performance", "abort"],
-      "example": "const controller = new AbortController(); fetch(url, { signal: controller.signal })"
-    },
-    {
-      "type": "best-practice",
-      "category": "Modern ES",
-      "title": "Use Object.hasOwn over hasOwnProperty",
-      "content": "Use `Object.hasOwn(obj, prop)` instead of `obj.hasOwnProperty(prop)`. It works on objects created with Object.create(null) and is more readable.",
-      "confidence": 0.8,
-      "tags": ["javascript", "es2022", "objects"]
-    }
-  ]
-}
+{
+  "id": "core/javascript",
+  "name": "JavaScript Fundamentals",
+  "version": "1.0.0",
+  "stack": ["javascript"],
+  "description": "Closures, event loop, async patterns, modern ES features, and coercion pitfalls",
+  "author": "claude-brain",
+  "entries": [
+    {
+      "type": "best-practice",
+      "category": "Async Patterns",
+      "title": "Use async/await over raw promises",
+      "content": "Prefer async/await over .then() chains for readability and debuggability. Async/await produces clearer stack traces and is easier to reason about for error handling with try/catch.",
+      "confidence": 0.95,
+      "tags": ["javascript", "async", "promises"]
+    },
+    {
+      "type": "common-issue",
+      "category": "Async Patterns",
+      "title": "Avoid unhandled promise rejections",
+      "content": "Always handle promise rejections with try/catch in async functions or .catch() on promises. Unhandled rejections can crash Node.js processes and cause silent failures in browsers.",
+      "confidence": 0.95,
+      "tags": ["javascript", "async", "error-handling"]
+    },
+    {
+      "type": "anti-pattern",
+      "category": "Async Patterns",
+      "title": "Avoid sequential awaits for independent operations",
+      "content": "Don't await independent async operations sequentially. Use Promise.all() or Promise.allSettled() to run them concurrently. Sequential awaits waste time waiting for operations that could run in parallel.",
+      "confidence": 0.9,
+      "tags": ["javascript", "async", "performance"],
+      "example": "const [users, posts] = await Promise.all([fetchUsers(), fetchPosts()])"
+    },
+    {
+      "type": "best-practice",
+      "category": "Modern ES",
+      "title": "Use destructuring for cleaner code",
+      "content": "Use destructuring assignment for objects and arrays to extract values concisely. This reduces intermediate variables and makes function parameter expectations clearer.",
+      "confidence": 0.9,
+      "tags": ["javascript", "es6", "destructuring"],
+      "example": "const { name, age } = user; const [first, ...rest] = items;"
+    },
+    {
+      "type": "best-practice",
+      "category": "Modern ES",
+      "title": "Prefer const, use let sparingly, avoid var",
+      "content": "Use `const` by default for all bindings. Only use `let` when reassignment is necessary. Never use `var` — it has function scoping and hoisting that causes bugs.",
+      "confidence": 0.95,
+      "tags": ["javascript", "variables", "scoping"]
+    },
+    {
+      "type": "common-issue",
+      "category": "Closures",
+      "title": "Understand closure variable capture",
+      "content": "Closures capture variables by reference, not by value. In loops, use `let` (block-scoped) instead of `var` to ensure each iteration gets its own copy. Arrow functions in loops with `var` all share the same variable.",
+      "confidence": 0.9,
+      "tags": ["javascript", "closures", "scoping"]
+    },
+    {
+      "type": "common-issue",
+      "category": "Event Loop",
+      "title": "Understand microtask vs macrotask ordering",
+      "content": "Promise callbacks (microtasks) run before setTimeout/setInterval callbacks (macrotasks). This matters for operation ordering. process.nextTick runs before all other microtasks in Node.js.",
+      "confidence": 0.85,
+      "tags": ["javascript", "event-loop", "async"]
+    },
+    {
+      "type": "anti-pattern",
+      "category": "Coercion",
+      "title": "Avoid loose equality (==)",
+      "content": "Always use strict equality (===) to avoid JavaScript's type coercion rules. Loose equality has unintuitive results like `'' == 0` being true and `null == undefined` being true.",
+      "confidence": 0.95,
+      "tags": ["javascript", "equality", "coercion"]
+    },
+    {
+      "type": "best-practice",
+      "category": "Modern ES",
+      "title": "Use optional chaining and nullish coalescing",
+      "content": "Use `?.` for safe property access on potentially null/undefined values. Use `??` for default values (only triggers on null/undefined, unlike `||` which triggers on falsy values).",
+      "confidence": 0.9,
+      "tags": ["javascript", "null-safety", "es2020"],
+      "example": "const name = user?.profile?.name ?? 'Anonymous'"
+    },
+    {
+      "type": "pattern",
+      "category": "Error Handling",
+      "title": "Create custom error classes for domain errors",
+      "content": "Extend the Error class for domain-specific errors. Include error codes, HTTP status codes, or other structured data to enable programmatic error handling.",
+      "confidence": 0.85,
+      "tags": ["javascript", "error-handling"],
+      "example": "class NotFoundError extends Error { constructor(resource) { super(`${resource} not found`); this.name = 'NotFoundError'; this.status = 404; } }"
+    },
+    {
+      "type": "best-practice",
+      "category": "Modern ES",
+      "title": "Use spread operator for immutable updates",
+      "content": "Use the spread operator to create shallow copies when updating objects or arrays. This supports immutable patterns without external libraries.",
+      "confidence": 0.9,
+      "tags": ["javascript", "immutability", "spread"],
+      "example": "const updated = { ...user, name: 'New Name' }"
+    },
+    {
+      "type": "common-issue",
+      "category": "Modern ES",
+      "title": "Understand shallow vs deep copy",
+      "content": "Spread and Object.assign only create shallow copies. Nested objects are still references. Use structuredClone() for deep copies, or libraries like immer for complex immutable updates.",
+      "confidence": 0.9,
+      "tags": ["javascript", "immutability", "deep-copy"]
+    },
+    {
+      "type": "anti-pattern",
+      "category": "Functions",
+      "title": "Avoid modifying function arguments",
+      "content": "Don't mutate objects or arrays passed as function arguments. This causes action-at-a-distance bugs. Return new values instead of modifying inputs.",
+      "confidence": 0.85,
+      "tags": ["javascript", "functions", "immutability"]
+    },
+    {
+      "type": "best-practice",
+      "category": "Modules",
+      "title": "Use ES modules (import/export)",
+      "content": "Prefer ES modules over CommonJS require(). ESM enables static analysis, tree-shaking, and top-level await. Most modern tools and runtimes support ESM natively.",
+      "confidence": 0.9,
+      "tags": ["javascript", "modules", "esm"]
+    },
+    {
+      "type": "pattern",
+      "category": "Arrays",
+      "title": "Use array methods for data transformations",
+      "content": "Prefer map, filter, reduce, find, and some over imperative loops for data transformations. They're more declarative, composable, and less error-prone.",
+      "confidence": 0.85,
+      "tags": ["javascript", "arrays", "functional"]
+    },
+    {
+      "type": "common-issue",
+      "category": "Coercion",
+      "title": "Be cautious with truthy/falsy checks",
+      "content": "JavaScript has six falsy values: false, 0, '', null, undefined, NaN. Be explicit when checking for null/undefined vs falsy. `if (value)` will miss 0 and empty string.",
+      "confidence": 0.9,
+      "tags": ["javascript", "coercion", "truthiness"]
+    },
+    {
+      "type": "best-practice",
+      "category": "Modern ES",
+      "title": "Use Map and Set for appropriate data structures",
+      "content": "Use Map instead of plain objects when keys are dynamic or non-string. Use Set for unique collections. Both have better performance characteristics and cleaner APIs than object-based alternatives.",
+      "confidence": 0.85,
+      "tags": ["javascript", "data-structures", "es6"]
+    },
+    {
+      "type": "anti-pattern",
+      "category": "Async Patterns",
+      "title": "Avoid mixing callbacks and promises",
+      "content": "Don't mix callback-style and promise-style async code. Use util.promisify() or write promise wrappers to convert callback APIs. Mixing styles leads to unhandled errors and confusing control flow.",
+      "confidence": 0.9,
+      "tags": ["javascript", "async", "callbacks"]
+    },
+    {
+      "type": "pattern",
+      "category": "Performance",
+      "title": "Use AbortController for cancellable operations",
+      "content": "Use AbortController with AbortSignal for cancellable fetch requests, event listeners, and async operations. This prevents memory leaks from abandoned operations.",
+      "confidence": 0.85,
+      "tags": ["javascript", "performance", "abort"],
+      "example": "const controller = new AbortController(); fetch(url, { signal: controller.signal })"
+    },
+    {
+      "type": "best-practice",
+      "category": "Modern ES",
+      "title": "Use Object.hasOwn over hasOwnProperty",
+      "content": "Use `Object.hasOwn(obj, prop)` instead of `obj.hasOwnProperty(prop)`. It works on objects created with Object.create(null) and is more readable.",
+      "confidence": 0.8,
+      "tags": ["javascript", "es2022", "objects"]
+    }
+  ]
+}