@harness-engineering/cli 1.23.2 → 1.24.1

package/dist/agents/skills/gemini-cli/js-flyweight-pattern/skill.yaml

@@ -0,0 +1,37 @@
+name: js-flyweight-pattern
+version: '1.0.0'
+description: Share common state across many fine-grained objects to reduce memory usage
+stability: static
+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-factory-pattern
+  - js-singleton-pattern
+stack_signals:
+  - javascript
+keywords:
+  - flyweight
+  - memory-optimization
+  - shared-state
+  - intrinsic
+  - extrinsic
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/flyweight-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/gemini-cli/js-iterator-pattern/SKILL.md

@@ -0,0 +1,78 @@
+# JS Iterator Pattern
+
+> Traverse a collection sequentially without exposing its internal structure
+
+## When to Use
+
+- You need to iterate over a custom data structure (tree, graph, linked list) with `for...of`
+- You want to provide lazy, on-demand values without generating the entire collection upfront
+- Building data pipelines that compose iterables (filter, map, take)
+
+## Instructions
+
+1. Implement the iterator protocol: an object with a `next()` method returning `{ value, done }`.
+2. Make a collection iterable by adding `[Symbol.iterator]()` that returns an iterator.
+3. Use generator functions (`function*`) for the cleanest iterator implementation.
+4. Use `for...of` to consume iterables.
+
+```javascript
+class Range {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+  }
+
+  [Symbol.iterator]() {
+    let current = this.start;
+    const end = this.end;
+    return {
+      next() {
+        return current <= end
+          ? { value: current++, done: false }
+          : { value: undefined, done: true };
+      },
+    };
+  }
+}
+
+for (const n of new Range(1, 3)) {
+  console.log(n); // 1, 2, 3
+}
+```
+
+5. Generator shorthand: `*[Symbol.iterator]() { for (let i = this.start; i <= this.end; i++) yield i; }`.
+
+## Details
+
+JavaScript has a built-in iteration protocol. Any object with a `[Symbol.iterator]()` method is iterable and works with `for...of`, spread (`...`), destructuring, `Array.from()`, and `Promise.all()`. Generators (`function*`) are the simplest way to create custom iterators.
+
+**Trade-offs:**
+
+- Custom iterators add complexity — only worthwhile for non-trivial data structures
+- Infinite iterators (no `done: true`) will hang `for...of` loops unless guarded
+- Generator objects are single-use — once exhausted, they cannot be reset
+
+**When NOT to use:**
+
+- For arrays and built-in collections — they are already iterable
+- When you need random access — iterators are sequential by design
+
+## Source
+
+https://patterns.dev/javascript/iterator-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/gemini-cli/js-iterator-pattern/skill.yaml

@@ -0,0 +1,37 @@
+name: js-iterator-pattern
+version: '1.0.0'
+description: Traverse a collection sequentially without exposing its internal structure
+stability: static
+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-command-pattern
+  - js-composite-pattern
+stack_signals:
+  - javascript
+keywords:
+  - iterator
+  - iterable
+  - symbol-iterator
+  - for-of
+  - generator
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/iterator-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/gemini-cli/js-mediator-middleware-pattern/SKILL.md

@@ -0,0 +1,92 @@
+# JS Mediator / Middleware Pattern
+
+> Route component interactions through a central mediator to reduce direct coupling
+
+## When to Use
+
+- Multiple components need to communicate without knowing about each other
+- You want to add cross-cutting concerns (logging, auth, validation) to a request pipeline
+- Implementing middleware chains (Express-style `next()` pipelines)
+
+## Instructions
+
+1. **Mediator:** Create a central object that components register with. Components send messages to the mediator, not to each other.
+2. **Middleware:** Define a chain of functions that each receive `(req, res, next)` (or equivalent) and call `next()` to pass control.
+3. Keep the mediator/middleware functions pure — no shared mutable state between middleware steps.
+4. Provide a way to skip remaining middleware (`next('skip')` or returning early).
+
+```javascript
+// Middleware pipeline
+class Pipeline {
+  constructor() {
+    this.middlewares = [];
+  }
+
+  use(fn) {
+    this.middlewares.push(fn);
+    return this;
+  }
+
+  execute(context) {
+    let index = 0;
+    const next = () => {
+      const fn = this.middlewares[index++];
+      if (fn) fn(context, next);
+    };
+    next();
+  }
+}
+
+const pipeline = new Pipeline();
+pipeline
+  .use((ctx, next) => {
+    ctx.log = [];
+    next();
+  })
+  .use((ctx, next) => {
+    ctx.log.push('step1');
+    next();
+  })
+  .use((ctx) => {
+    ctx.log.push('step2');
+  });
+
+const ctx = {};
+pipeline.execute(ctx);
+console.log(ctx.log); // ['step1', 'step2']
+```
+
+## Details
+
+The Mediator pattern (GoF) centralizes communication. The Middleware pattern (popularized by Express.js) is a sequential pipeline variant. Both reduce point-to-point coupling by routing interactions through a shared hub or chain.
+
+**Trade-offs:**
+
+- The mediator becomes a bottleneck and a single point of failure if overloaded
+- Middleware chains are hard to debug — add logging middleware during development
+- Order of middleware registration matters and can cause subtle bugs
+
+**When NOT to use:**
+
+- For simple two-component communication — a direct callback or event is simpler
+- When the pipeline steps need full knowledge of each other — mediator will not help
+
+## Source
+
+https://patterns.dev/javascript/mediator-middleware-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/gemini-cli/js-mediator-middleware-pattern/skill.yaml

@@ -0,0 +1,37 @@
+name: js-mediator-middleware-pattern
+version: '1.0.0'
+description: Route component interactions through a central mediator to reduce coupling
+stability: static
+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-observer-pattern
+  - js-command-pattern
+stack_signals:
+  - javascript
+keywords:
+  - mediator
+  - middleware
+  - pipeline
+  - central-hub
+  - decoupling
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/mediator-middleware-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/gemini-cli/js-mixin-pattern/SKILL.md

@@ -0,0 +1,85 @@
+# JS Mixin Pattern
+
+> Add reusable behaviors to classes without deep inheritance chains
+
+## When to Use
+
+- Multiple unrelated classes need the same capability (e.g., serialization, event handling, logging)
+- Single inheritance is not sufficient to compose all required behaviors
+- You want to share behavior without creating a shared base class
+
+## Instructions
+
+1. Define a mixin as a function that takes a superclass and returns a new class extending it.
+2. Apply mixins by chaining: `class MyClass extends Mixin2(Mixin1(Base)) {}`.
+3. Keep mixins focused on a single capability — avoid fat mixins that do too much.
+4. Alternatively, use `Object.assign(Target.prototype, mixinMethods)` for simpler method injection.
+
+```javascript
+// Functional mixin approach
+const Serializable = (Base) =>
+  class extends Base {
+    serialize() {
+      return JSON.stringify(this);
+    }
+    static deserialize(json) {
+      return Object.assign(new this(), JSON.parse(json));
+    }
+  };
+
+const Timestamped = (Base) =>
+  class extends Base {
+    constructor(...args) {
+      super(...args);
+      this.createdAt = new Date();
+    }
+  };
+
+class User extends Serializable(Timestamped(class {})) {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+}
+
+const u = new User('Alice');
+console.log(u.serialize()); // {"name":"Alice","createdAt":"..."}
+```
+
+5. Use TypeScript intersection types to type mixed-in methods correctly.
+
+## Details
+
+JavaScript's single-prototype-chain inheritance means a class can only extend one parent. Mixins work around this by composing behaviors through function application rather than inheritance.
+
+**Trade-offs:**
+
+- Method name collisions between mixins are silent — the last applied mixin wins
+- Stack traces can be confusing — intermediate mixin classes appear in the trace
+- `instanceof` checks do not work for mixins applied via `Object.assign` (only for the class mixin approach)
+
+**When NOT to use:**
+
+- When composition via plain function calls or hooks would work just as well
+- When the behaviors are tightly coupled to specific base classes — inheritance is cleaner
+- For simple utility methods — just import a utility function
+
+## Source
+
+https://patterns.dev/javascript/mixin-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/gemini-cli/js-mixin-pattern/skill.yaml

@@ -0,0 +1,36 @@
+name: js-mixin-pattern
+version: '1.0.0'
+description: Add reusable behaviors to classes without deep inheritance chains
+stability: static
+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:
+  - mixin
+  - composition
+  - multiple-inheritance
+  - object-assign
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/mixin-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/gemini-cli/js-module-pattern/SKILL.md

@@ -0,0 +1,75 @@
+# JS Module Pattern
+
+> Encapsulate private state and expose a public API using closures or ES modules
+
+## When to Use
+
+- You need private variables that are not accessible from outside a module
+- You want a clean public API with implementation details hidden
+- You are working in a pre-ESM environment where IIFE-based modules were the norm
+
+## Instructions
+
+1. In modern code (ESM), declare module-level variables as private by not exporting them. Export only the public API.
+2. In legacy or bundled code, use an IIFE to create a closure scope.
+3. Freeze exported objects if they should be immutable.
+4. Keep modules focused — one module per concern.
+
+```javascript
+// Modern ESM module pattern
+let _count = 0; // private — not exported
+
+export function increment() {
+  _count++;
+}
+
+export function getCount() {
+  return _count;
+}
+
+// Legacy IIFE module pattern
+const counter = (() => {
+  let _count = 0;
+  return {
+    increment: () => _count++,
+    getCount: () => _count,
+  };
+})();
+```
+
+5. Prefer ESM named exports over default exports for better tree-shaking.
+
+## Details
+
+The Module pattern predates ES modules. In the browser, there was no built-in module system, so developers used IIFEs (Immediately Invoked Function Expressions) to create private scopes. Today, ES modules (`.mjs`, `type="module"`) provide native module semantics — each file gets its own scope.
+
+**Trade-offs:**
+
+- Module-level state is shared across all importers in the same process — it is a singleton
+- IIFE modules are not tree-shakeable by bundlers; prefer named ESM exports
+- Circular module dependencies can cause initialization order issues
+
+**When NOT to use:**
+
+- When you need per-instance private state — use classes with private fields (`#field`)
+- When the module has no state — just export pure functions directly
+
+## Source
+
+https://patterns.dev/javascript/module-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/gemini-cli/js-module-pattern/skill.yaml

@@ -0,0 +1,37 @@
+name: js-module-pattern
+version: '1.0.0'
+description: Encapsulate private state and expose a public API using closures or ES modules
+stability: static
+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-revealing-module-pattern
+  - js-singleton-pattern
+stack_signals:
+  - javascript
+keywords:
+  - module
+  - encapsulation
+  - private-state
+  - iife
+  - esm
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/module-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/gemini-cli/js-observer-pattern/SKILL.md

@@ -0,0 +1,81 @@
+# JS Observer Pattern
+
+> Notify subscribers automatically when an observable object's state changes
+
+## When to Use
+
+- Multiple parts of the app need to react to the same event without coupling the emitter to its consumers
+- Implementing event systems, reactive UI updates, or real-time data feeds
+- Decoupling data sources from their consumers
+
+## Instructions
+
+1. Create an observable with an `observers` array and `subscribe` / `unsubscribe` / `notify` methods.
+2. Call `notify(data)` whenever the observable's state changes — it invokes all subscribed callbacks.
+3. Always provide `unsubscribe` — failing to unsubscribe causes memory leaks in long-lived apps.
+4. In browser environments, prefer native `EventTarget` or `EventEmitter` (Node.js) over hand-rolled implementations.
+
+```javascript
+class Observable {
+  constructor() {
+    this.observers = [];
+  }
+
+  subscribe(fn) {
+    this.observers.push(fn);
+    return () => this.unsubscribe(fn); // return cleanup function
+  }
+
+  unsubscribe(fn) {
+    this.observers = this.observers.filter((obs) => obs !== fn);
+  }
+
+  notify(data) {
+    this.observers.forEach((fn) => fn(data));
+  }
+}
+
+const store = new Observable();
+const cleanup = store.subscribe((data) => console.log('Received:', data));
+store.notify({ type: 'UPDATE', payload: 42 });
+cleanup(); // unsubscribe
+```
+
+5. Return a cleanup/unsubscribe function from `subscribe` — consumers call it to remove the handler.
+
+## Details
+
+The Observer pattern (also called pub/sub) separates the emitter (subject/observable) from its consumers (observers/subscribers). This decoupling is fundamental to event-driven architectures, reactive state systems, and streams.
+
+**Trade-offs:**
+
+- If observers are not unsubscribed, the observable holds references to them — memory leak risk in SPAs
+- Cascade updates — one observable notifying many observers can cause complex update chains that are hard to trace
+- No guaranteed delivery order unless explicitly enforced
+- Debugging is harder than direct calls — add logging in `notify()` during development
+
+**When NOT to use:**
+
+- When only one consumer exists — a direct callback is simpler
+- When the update sequence matters and subscribers need to be ordered — use a queue or middleware chain instead
+- For synchronous, predictable data flow — use signals or reducers
+
+## Source
+
+https://patterns.dev/javascript/observer-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/gemini-cli/js-observer-pattern/skill.yaml

@@ -0,0 +1,37 @@
+name: js-observer-pattern
+version: '1.0.0'
+description: Notify subscribers automatically when an observable object's state changes
+stability: static
+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-proxy-pattern
+  - js-mediator-middleware-pattern
+stack_signals:
+  - javascript
+keywords:
+  - observer
+  - pub-sub
+  - event-emitter
+  - subscribe
+  - notify
+metadata:
+  author: patterns.dev
+  upstream: 'PatternsDev/skills/javascript/observer-pattern'
+state:
+  persistent: false
+  files: []
+depends_on: []