@harness-engineering/cli 1.23.1 → 1.24.0

package/dist/agents/skills/cursor/js-adapter-pattern/skill.yaml

@@ -0,0 +1,35 @@
+name: js-adapter-pattern
+version: '1.0.0'
+description: Convert the interface of a class into another interface that clients expect
+cognitive_mode: advisory-guide
+type: knowledge
+tier: 3
+triggers:
+  - manual
+platforms:
+  - claude-code
+  - gemini-cli
+  - cursor
+  - codex
+tools: []
+paths:
+  - '**/*.js'
+  - '**/*.mjs'
+  - '**/*.cjs'
+related_skills:
+  - js-facade-pattern
+  - js-decorator-pattern
+stack_signals:
+  - javascript
+keywords:
+  - adapter
+  - wrapper
+  - interface-compatibility
+  - legacy-integration
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/adapter-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/cursor/js-bridge-pattern/SKILL.md

@@ -0,0 +1,90 @@
+# JS Bridge Pattern
+
+> Decouple abstraction from implementation so both can vary independently
+
+## When to Use
+
+- You want to avoid a combinatorial explosion of classes when abstractions and implementations vary orthogonally
+- The implementation should be swappable at runtime (e.g., different rendering backends)
+- You need to extend both the abstraction and the implementation hierarchies independently
+
+## Instructions
+
+1. Separate the abstraction (high-level logic) from the implementation (low-level detail).
+2. The abstraction holds a reference to an implementation object.
+3. Both can be subclassed independently — new abstractions do not require new implementations and vice versa.
+4. Inject the implementation via the constructor.
+
+```javascript
+// Implementation interface
+class Renderer {
+  renderCircle(radius) {
+    throw new Error('Not implemented');
+  }
+}
+
+class SVGRenderer extends Renderer {
+  renderCircle(radius) {
+    return `<circle r="${radius}"/>`;
+  }
+}
+
+class CanvasRenderer extends Renderer {
+  renderCircle(radius) {
+    return `ctx.arc(0,0,${radius},0,2*PI)`;
+  }
+}
+
+// Abstraction
+class Shape {
+  constructor(renderer) {
+    this.renderer = renderer;
+  }
+}
+
+class Circle extends Shape {
+  constructor(radius, renderer) {
+    super(renderer);
+    this.radius = radius;
+  }
+  draw() {
+    return this.renderer.renderCircle(this.radius);
+  }
+}
+```
+
+## Details
+
+The Bridge pattern separates an abstraction from its implementation so that the two can evolve independently. Without Bridge, combining M abstractions with N implementations requires M\*N classes. With Bridge, it requires M + N.
+
+**Trade-offs:**
+
+- More complex initial setup — two parallel hierarchies
+- Adds indirection — the abstraction delegates to the implementation
+- Over-engineering for simple cases with one abstraction and one implementation
+
+**When NOT to use:**
+
+- When there is only one implementation — just use it directly
+- When the abstraction and implementation are tightly coupled and always change together
+- For simple delegation — a function parameter is clearer than the full Bridge structure
+
+## Source
+
+https://patterns.dev/javascript/bridge-pattern
+
+## Process
+
+1. Read the instructions and examples in this document.
+2. Apply the patterns to your implementation, adapting to your specific context.
+3. Verify your implementation against the details and edge cases listed above.
+
+## Harness Integration
+
+- **Type:** knowledge — this skill is a reference document, not a procedural workflow.
+- **No tools or state** — consumed as context by other skills and agents.
+
+## Success Criteria
+
+- The patterns described in this document are applied correctly in the implementation.
+- Edge cases and anti-patterns listed in this document are avoided.

package/dist/agents/skills/cursor/js-bridge-pattern/skill.yaml

@@ -0,0 +1,35 @@
+name: js-bridge-pattern
+version: '1.0.0'
+description: Decouple abstraction from implementation so both can vary independently
+cognitive_mode: advisory-guide
+type: knowledge
+tier: 3
+triggers:
+  - manual
+platforms:
+  - claude-code
+  - gemini-cli
+  - cursor
+  - codex
+tools: []
+paths:
+  - '**/*.js'
+  - '**/*.mjs'
+  - '**/*.cjs'
+related_skills:
+  - js-adapter-pattern
+  - js-abstract-factory-pattern
+stack_signals:
+  - javascript
+keywords:
+  - bridge
+  - decoupling
+  - abstraction-implementation
+  - structural
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/bridge-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/cursor/js-chain-of-responsibility-pattern/SKILL.md

@@ -0,0 +1,81 @@
+# JS Chain of Responsibility Pattern
+
+> Pass a request along a chain of handlers until one handles it
+
+## When to Use
+
+- Multiple handlers might process a request, but you do not know which one at compile time
+- You want to decouple the sender from the receiver of a request
+- Building validation chains, auth pipelines, or event bubbling systems
+
+## Instructions
+
+1. Define a handler interface with a `handle(request)` method and a `setNext(handler)` reference.
+2. Each handler decides to process the request or pass it to the next handler in the chain.
+3. Build the chain by linking handlers: `h1.setNext(h2).setNext(h3)`.
+4. The client sends the request to the first handler — it does not know which handler will process it.
+
+```javascript
+class Handler {
+  setNext(handler) {
+    this.next = handler;
+    return handler;
+  }
+  handle(request) {
+    if (this.next) return this.next.handle(request);
+    return null;
+  }
+}
+
+class AuthHandler extends Handler {
+  handle(req) {
+    if (!req.token) return { error: 'Unauthorized' };
+    return super.handle(req);
+  }
+}
+
+class RateLimitHandler extends Handler {
+  handle(req) {
+    if (req.rateLimited) return { error: 'Too many requests' };
+    return super.handle(req);
+  }
+}
+```
+
+5. Return a result from the handler that processes the request, or a default/null if no handler matches.
+
+## Details
+
+The Chain of Responsibility pattern decouples senders from receivers by giving multiple objects a chance to handle a request. The request travels along the chain until a handler processes it or it reaches the end. Express.js middleware is a functional variant of this pattern.
+
+**Trade-offs:**
+
+- No guarantee that any handler will process the request — you need a fallback
+- Debugging can be difficult — the request passes through multiple handlers invisibly
+- Long chains add latency and make the flow harder to trace
+
+**When NOT to use:**
+
+- When there is always exactly one handler — route directly to it
+- When all handlers must process the request (not just the first match) — use Observer pattern instead
+- For simple conditional logic — an if/else is more explicit
+
+## Source
+
+https://patterns.dev/javascript/chain-of-responsibility-pattern
+
+## Process
+
+1. Read the instructions and examples in this document.
+2. Apply the patterns to your implementation, adapting to your specific context.
+3. Verify your implementation against the details and edge cases listed above.
+
+## Harness Integration
+
+- **Type:** knowledge — this skill is a reference document, not a procedural workflow.
+- **No tools or state** — consumed as context by other skills and agents.
+
+## Success Criteria
+
+- The patterns described in this document are applied correctly in the implementation.
+- Edge cases and anti-patterns listed in this document are avoided.

package/dist/agents/skills/cursor/js-chain-of-responsibility-pattern/skill.yaml

@@ -0,0 +1,35 @@
+name: js-chain-of-responsibility-pattern
+version: '1.0.0'
+description: Pass a request along a chain of handlers until one handles it
+cognitive_mode: advisory-guide
+type: knowledge
+tier: 3
+triggers:
+  - manual
+platforms:
+  - claude-code
+  - gemini-cli
+  - cursor
+  - codex
+tools: []
+paths:
+  - '**/*.js'
+  - '**/*.mjs'
+  - '**/*.cjs'
+related_skills:
+  - js-mediator-middleware-pattern
+  - js-command-pattern
+stack_signals:
+  - javascript
+keywords:
+  - chain-of-responsibility
+  - handler-chain
+  - request-pipeline
+  - middleware
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/chain-of-responsibility-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/cursor/js-command-pattern/SKILL.md

@@ -0,0 +1,81 @@
+# JS Command Pattern
+
+> Encapsulate operations as objects to support undo, queue, and logging
+
+## When to Use
+
+- You need undo/redo functionality
+- Operations should be queued, deferred, or logged
+- You want to decouple the sender of an operation from its executor
+
+## Instructions
+
+1. Define a command interface with `execute()` and optionally `undo()` methods.
+2. Each command class captures the receiver and parameters needed to perform (and reverse) the operation.
+3. Store executed commands in a history stack for undo support.
+4. The invoker (button, menu, keyboard shortcut) calls `command.execute()` without knowing the implementation.
+
+```javascript
+class AddTextCommand {
+  constructor(editor, text) {
+    this.editor = editor;
+    this.text = text;
+    this.prevContent = null;
+  }
+
+  execute() {
+    this.prevContent = this.editor.content;
+    this.editor.content += this.text;
+  }
+
+  undo() {
+    this.editor.content = this.prevContent;
+  }
+}
+
+const editor = { content: 'Hello' };
+const history = [];
+
+const cmd = new AddTextCommand(editor, ' World');
+cmd.execute();
+history.push(cmd);
+console.log(editor.content); // 'Hello World'
+
+history.pop().undo();
+console.log(editor.content); // 'Hello'
+```
+
+## Details
+
+The Command pattern turns function calls into first-class objects. This makes operations serializable, loggable, and reversible. Redux actions are a functional variant of this pattern.
+
+**Trade-offs:**
+
+- More boilerplate than a direct function call
+- Memory cost for storing command history
+- Undo logic can be complex for operations with side effects
+
+**When NOT to use:**
+
+- When undo/redo is not needed and operations are one-shot
+- For simple event handlers — a plain callback is sufficient
+
+## Source
+
+https://patterns.dev/javascript/command-pattern
+
+## Process
+
+1. Read the instructions and examples in this document.
+2. Apply the patterns to your implementation, adapting to your specific context.
+3. Verify your implementation against the details and edge cases listed above.
+
+## Harness Integration
+
+- **Type:** knowledge — this skill is a reference document, not a procedural workflow.
+- **No tools or state** — consumed as context by other skills and agents.
+
+## Success Criteria
+
+- The patterns described in this document are applied correctly in the implementation.
+- Edge cases and anti-patterns listed in this document are avoided.

package/dist/agents/skills/cursor/js-command-pattern/skill.yaml

@@ -0,0 +1,36 @@
+name: js-command-pattern
+version: '1.0.0'
+description: Encapsulate operations as objects to support undo, queue, and logging
+cognitive_mode: advisory-guide
+type: knowledge
+tier: 3
+triggers:
+  - manual
+platforms:
+  - claude-code
+  - gemini-cli
+  - cursor
+  - codex
+tools: []
+paths:
+  - '**/*.js'
+  - '**/*.mjs'
+  - '**/*.cjs'
+related_skills:
+  - js-mediator-middleware-pattern
+  - js-iterator-pattern
+stack_signals:
+  - javascript
+keywords:
+  - command
+  - undo
+  - redo
+  - action
+  - encapsulate-operation
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/command-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/cursor/js-composite-pattern/SKILL.md

@@ -0,0 +1,83 @@
+# JS Composite Pattern
+
+> Compose objects into tree structures and treat individual objects and composites uniformly
+
+## When to Use
+
+- You have a tree/hierarchy structure (file system, org chart, UI component tree, menu system)
+- Clients should treat individual objects and groups of objects the same way
+- Operations need to recurse naturally over the tree
+
+## Instructions
+
+1. Define a component interface with the operation that both leaves and composites share.
+2. Leaf classes implement the operation directly.
+3. Composite classes hold a collection of children and delegate the operation to each child.
+4. Clients call the operation on any component without checking whether it is a leaf or composite.
+
+```javascript
+class File {
+  constructor(name, size) {
+    this.name = name;
+    this.size = size;
+  }
+  getSize() {
+    return this.size;
+  }
+}
+
+class Folder {
+  constructor(name) {
+    this.name = name;
+    this.children = [];
+  }
+  add(child) {
+    this.children.push(child);
+    return this;
+  }
+  getSize() {
+    return this.children.reduce((sum, child) => sum + child.getSize(), 0);
+  }
+}
+
+const root = new Folder('src')
+  .add(new File('index.js', 120))
+  .add(new Folder('utils').add(new File('helpers.js', 80)));
+root.getSize(); // 200
+```
+
+## Details
+
+The Composite pattern lets you build tree structures where clients do not need to distinguish between leaves and branches. Every node in the tree responds to the same interface, so operations naturally recurse.
+
+**Trade-offs:**
+
+- The uniform interface may expose methods on leaves that do not make sense (e.g., `add()` on a File)
+- Deep trees can cause stack overflows with recursive operations — consider iterative traversal for very large trees
+- Type checking is harder — all nodes look the same at the interface level
+
+**When NOT to use:**
+
+- When the structure is flat (no nesting) — just use an array
+- When leaves and composites have very different behaviors — forcing a common interface is awkward
+- When the hierarchy is dynamic and deeply nested — consider a database or graph instead
+
+## Source
+
+https://patterns.dev/javascript/composite-pattern
+
+## Process
+
+1. Read the instructions and examples in this document.
+2. Apply the patterns to your implementation, adapting to your specific context.
+3. Verify your implementation against the details and edge cases listed above.
+
+## Harness Integration
+
+- **Type:** knowledge — this skill is a reference document, not a procedural workflow.
+- **No tools or state** — consumed as context by other skills and agents.
+
+## Success Criteria
+
+- The patterns described in this document are applied correctly in the implementation.
+- Edge cases and anti-patterns listed in this document are avoided.

package/dist/agents/skills/cursor/js-composite-pattern/skill.yaml

@@ -0,0 +1,35 @@
+name: js-composite-pattern
+version: '1.0.0'
+description: Compose objects into tree structures and treat individual objects and composites uniformly
+cognitive_mode: advisory-guide
+type: knowledge
+tier: 3
+triggers:
+  - manual
+platforms:
+  - claude-code
+  - gemini-cli
+  - cursor
+  - codex
+tools: []
+paths:
+  - '**/*.js'
+  - '**/*.mjs'
+  - '**/*.cjs'
+related_skills:
+  - js-iterator-pattern
+  - js-visitor-pattern
+stack_signals:
+  - javascript
+keywords:
+  - composite
+  - tree-structure
+  - uniform-treatment
+  - recursive-composition
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/composite-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/cursor/js-constructor-pattern/SKILL.md

@@ -0,0 +1,78 @@
+# JS Constructor Pattern
+
+> Use constructor functions or ES6 classes to create and initialize objects
+
+## When to Use
+
+- You need to create multiple instances of the same type with shared methods
+- Object initialization has meaningful logic (validation, default values, derived properties)
+- You want to use `instanceof` for type checking
+
+## Instructions
+
+1. Use ES6 `class` syntax over function constructors for readability.
+2. Put per-instance data in the constructor (`this.x = ...`).
+3. Put shared methods on the class body (they go on the prototype automatically).
+4. Use private class fields (`#field`) for data that should not be accessible externally.
+
+```javascript
+class Rectangle {
+  #area = null;
+
+  constructor(width, height) {
+    if (width <= 0 || height <= 0) throw new RangeError('Dimensions must be positive');
+    this.width = width;
+    this.height = height;
+  }
+
+  getArea() {
+    if (this.#area === null) {
+      this.#area = this.width * this.height; // memoize
+    }
+    return this.#area;
+  }
+
+  toString() {
+    return `Rectangle(${this.width}x${this.height})`;
+  }
+}
+
+const r = new Rectangle(4, 5);
+console.log(r.getArea()); // 20
+console.log(r instanceof Rectangle); // true
+```
+
+## Details
+
+The Constructor pattern is the foundation of object-oriented JavaScript. ES6 classes are syntactic sugar over prototype-based inheritance — `class` bodies define methods on `ClassName.prototype`, exactly like the older `function Constructor() {}` approach.
+
+**Trade-offs:**
+
+- Classes encourage mutation via `this` — prefer immutable value objects for data
+- `this` binding issues arise when class methods are passed as callbacks — use arrow functions or `.bind()`
+- Private fields (`#field`) are not accessible in subclasses without getters
+
+**When NOT to use:**
+
+- For simple data bags with no behavior — plain object literals are lighter
+- When functional composition (factory functions + closures) better fits the architecture
+
+## Source
+
+https://patterns.dev/javascript/constructor-pattern
+
+## Process
+
+1. Read the instructions and examples in this document.
+2. Apply the patterns to your implementation, adapting to your specific context.
+3. Verify your implementation against the details and edge cases listed above.
+
+## Harness Integration
+
+- **Type:** knowledge — this skill is a reference document, not a procedural workflow.
+- **No tools or state** — consumed as context by other skills and agents.
+
+## Success Criteria
+
+- The patterns described in this document are applied correctly in the implementation.
+- Edge cases and anti-patterns listed in this document are avoided.

package/dist/agents/skills/cursor/js-constructor-pattern/skill.yaml

@@ -0,0 +1,36 @@
+name: js-constructor-pattern
+version: '1.0.0'
+description: Use constructor functions or classes to create and initialize objects
+cognitive_mode: advisory-guide
+type: knowledge
+tier: 3
+triggers:
+  - manual
+platforms:
+  - claude-code
+  - gemini-cli
+  - cursor
+  - codex
+tools: []
+paths:
+  - '**/*.js'
+  - '**/*.mjs'
+  - '**/*.cjs'
+related_skills:
+  - js-prototype-pattern
+  - js-factory-pattern
+stack_signals:
+  - javascript
+keywords:
+  - constructor
+  - class
+  - new
+  - instantiation
+  - initialization
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/constructor-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []