@wrongstack/core 0.1.0

package/skills/multi-agent/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: multi-agent
+description: |
+  Multi-agent orchestration workflow. Covers leader/worker roles,
+  task delegation, done conditions, and result aggregation.
+  Use for parallel task execution.
+version: 1.0.0
+---
+
+# Multi-Agent Coordination
+
+Guide for orchestrating multiple agents to work together on complex tasks.
+
+## When to use multiple agents
+
+- Large refactoring across multiple modules
+- Parallel feature development
+- Code review + implementation simultaneously
+- Any task where separation of concerns speeds things up
+
+## Agent roles
+
+Define clear roles to avoid overlap:
+
+- **Leader** — Coordinates, delegates, synthesizes
+- **Worker** — Executes specific tasks
+- **Reviewer** — Reviews and approves
+- **Architect** — Makes design decisions
+- **Debugger** — Root cause analysis
+
+## Task delegation principles
+
+1. **Atomic tasks** — Each task should be independently executable
+2. **Clear boundaries** — Tasks should not overlap
+3. **Dependency awareness** — Respect task dependencies
+4. **Result aggregation** — Leader synthesizes worker results
+
+## Communication
+
+Agents communicate via structured messages:
+
+- `task` — Assign work
+- `result` — Return output
+- `progress` — Status updates
+- `error` — Failures
+- `stop` — Cancellation
+
+## Done conditions
+
+Choose appropriate done condition:
+
+- `all_tasks_done` — Wait for all tasks
+- `critical_path_done` — Wait for critical path
+- `first_completion` — Stop at first success
+- `max_iterations` — Bounded execution
+
+## Anti-patterns
+
+- Over-delegation — Don't fragment work too much
+- Under-delegation — Single agent bottleneck
+- Role confusion — Workers doing leadership work
+- Result loss — Not aggregating agent outputs

package/skills/node-modern/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: node-modern
+description: |
+  Use this skill for Node.js >= 22 idioms: ESM-only, native fetch, AbortSignal,
+  node: protocol imports, structuredClone, Web Streams, and modern async patterns.
+version: 1.0.0
+---
+
+# Modern Node.js (>= 22)
+
+## Imports
+
+- Always use `node:` protocol for built-ins: `import * as fs from 'node:fs/promises'`.
+- ESM only — no CommonJS in new code. Use `.js` extension in relative imports.
+- Prefer `import.meta` over `__dirname` (compute via `fileURLToPath`).
+
+## I/O
+
+- Use `fs.promises` (or `node:fs/promises`). Avoid the callback API.
+- Use native `fetch` — no axios, no node-fetch.
+- Use `AbortSignal` everywhere that takes time: fetch, child_process spawn, timers (via `setTimeout(..., { signal })`).
+
+## Patterns
+
+```ts
+// Combine signals
+const combined = AbortSignal.any([userSignal, timeoutSignal]);
+
+// Atomic write
+import { rename, writeFile } from 'node:fs/promises';
+const tmp = `${target}.${randomBytes(4).toString('hex')}.tmp`;
+await writeFile(tmp, data);
+await rename(tmp, target);
+```
+
+## Anti-patterns
+
+- `require()` in new code
+- `__dirname` without `fileURLToPath`
+- Mixing `fs.readFile` callback with `await`
+- Swallowing AbortError silently

package/skills/prompt-engineering/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: prompt-engineering
+description: |
+  Use this skill when designing system prompts, tool descriptions, or task
+  instructions for LLM agents. Covers structure, specificity, and common pitfalls.
+version: 1.0.0
+---
+
+# Prompt engineering
+
+## Structure
+
+- Identity → principles → environment → memory. (WrongStack's 4-layer system prompt.)
+- Static content first (cacheable), volatile last.
+- Markdown headings help models parse structure.
+
+## Tool descriptions
+
+- Describe *when* to use, not just *what*. "Use `read` before `edit`" is more useful than "reads files".
+- Include schema constraints in prose; the JSON schema alone is rarely enough.
+- Give one example for non-obvious tools.
+
+## Anti-patterns
+
+- "Please" / "kindly" — adds tokens, no benefit.
+- "You are a helpful AI assistant" — already implied, wastes tokens.
+- Long preamble before the actual question.
+- Ambiguous pronouns ("do it again") — names beat pronouns.

package/skills/react-modern/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: react-modern
+description: |
+  Use this skill when writing or reviewing React 19+ code. Covers Server
+  Components vs Client Components, useTransition, Suspense, the `use` hook,
+  Actions, and form state.
+version: 1.0.0
+---
+
+# Modern React (19+)
+
+## Component types
+
+- Default to Server Components for data fetching and static UI.
+- Mark interactive code with `'use client'` and keep it minimal.
+- Don't pass Server Components into Client Component children unless serialized.
+
+## Data fetching
+
+- In Server Components: `await fetch(...)`, server-side caching is automatic with framework support.
+- In Client Components: use a library (TanStack Query) or `use(promise)` for awaitable thenables.
+
+## State
+
+- `useState` for local state. `useReducer` for state machines.
+- `useTransition` for non-urgent updates that should not block input.
+- Avoid `useEffect` for derived state — compute during render.
+
+## Anti-patterns
+
+- `useEffect` to sync local state with props
+- Class components in new code
+- `forwardRef` in new code (React 19 makes `ref` a regular prop)
+- Default exports for components (named exports help refactor tools)

package/skills/sdd/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: sdd
+description: |
+  Specification-driven development workflow. Covers spec parsing,
+  task graph generation from requirements, dependency tracking, and
+  done-condition execution. Use when implementing features.
+version: 1.0.0
+---
+
+# Spec-Driven Development
+
+Guide the agent through specification-first development workflow.
+
+## Core Principle
+
+Every non-trivial change starts with a spec. The spec is the source of truth. Tasks are derived from specs, not the other way around.
+
+## Workflow
+
+```
+Spec → Analysis → Task Graph → Execution → Done
+```
+
+### When to use
+
+- New feature implementation
+- Bug fix with complexity
+- Refactoring with scope
+- Any task requiring more than 1 hour
+
+### Spec sections
+
+A good spec includes:
+
+1. **Overview** — What problem does this solve?
+2. **Requirements** — Functional and non-functional requirements with priorities
+3. **Architecture** — High-level design if needed
+4. **API Design** — If applicable
+5. **Data Model** — If applicable
+6. **Security** — Auth, permissions, data handling
+7. **Acceptance Criteria** — How do we know it's done?
+
+### Requirement format
+
+```
+[functional] User can authenticate with OAuth2
+[security] Rate limiting: 100 req/min per user
+[performance] Response time < 200ms p95
+```
+
+Priority markers: `[critical]`, `[high]`, `[medium]`, `[low]`
+
+## Task generation
+
+Tasks are derived from requirements:
+
+- Each requirement → one or more tasks
+- Requirements with acceptance criteria → separate test tasks
+- Critical requirements → tasks marked critical
+- Blocked requirements → blocked tasks
+
+## Task states
+
+```
+pending → in_progress → review → completed
+              ↓
+           blocked (waiting on dependencies)
+              ↓
+           failed
+```
+
+## Done conditions
+
+A feature is done when:
+1. All critical and high priority tasks completed
+2. Tests written and passing
+3. Documentation updated
+4. No blocked tasks remaining

package/skills/typescript-strict/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: typescript-strict
+description: |
+  Use this skill when writing or reviewing TypeScript code with strict mode.
+  Covers strict null checks, exhaustive switch, branded types, discriminated
+  unions, and noUncheckedIndexedAccess pitfalls.
+version: 1.0.0
+---
+
+# TypeScript strict mode
+
+## Core rules
+
+- `strict: true` is non-negotiable. So is `noUncheckedIndexedAccess: true`.
+- Never silence type errors with `as any`. Use `as unknown as T` only at trust boundaries with a comment explaining why.
+- Prefer discriminated unions over enums.
+- Use `readonly` aggressively on properties and arrays.
+
+## Common patterns
+
+### Exhaustive switch
+
+```ts
+function assertNever(x: never): never {
+  throw new Error(`Unhandled: ${JSON.stringify(x)}`);
+}
+
+switch (block.type) {
+  case 'text': return renderText(block);
+  case 'tool_use': return renderToolUse(block);
+  default: return assertNever(block);
+}
+```
+
+### Branded types for invariants
+
+```ts
+type UserId = string & { readonly __brand: 'UserId' };
+const toUserId = (s: string): UserId => s as UserId;
+```
+
+### noUncheckedIndexedAccess
+
+After enabling this, `arr[i]` is `T | undefined`. Don't disable it — handle the undefined explicitly.
+
+## Anti-patterns
+
+- `!` non-null assertion in production code (use a narrow check)
+- Returning `Promise<any>` from a public API
+- `Function` or `Object` types — always be specific