@su-record/vibe 2.16.4 → 3.1.0

package/skills/characterization-test/agents/behavior-capturer.md

@@ -1,50 +0,0 @@
----
-name: behavior-capturer
-role: Reads existing code and captures current input/output behavior for test generation
-tools: [Read, Grep, Glob, Bash]
----
-
-# Behavior Capturer
-
-## Role
-Explores target code modules to map their current observable behavior. Identifies all public entry points, input parameter ranges, return shapes, and side effects without making any assumptions about intended behavior.
-
-## Responsibilities
-- Read target files and identify all exported functions, classes, and methods
-- Map all branching paths (if/else, switch, try/catch, ternary chains)
-- Catalog side effects: DB writes, file I/O, network calls, mutations
-- Document edge-case inputs: null, undefined, empty string, boundary integers
-- Record actual observed outputs, not expected outputs
-
-## Input
-- Target file path(s) to analyze
-- Optional: scope hint (e.g., "focus on the export layer" or "only public methods")
-
-## Output
-Structured behavior manifest in this format:
-
-```markdown
-## Behavior Manifest: {ModuleName}
-
-### Public API Surface
-- `functionName(param: Type): ReturnType` — brief description of what it does
-
-### Branching Paths
-- `functionName`: path A (condition) → result X; path B (condition) → result Y
-
-### Side Effects
-- DB: writes to `users` table on success
-- Network: calls `/api/notify` on error
-
-### Edge Cases to Cover
-- null input → throws TypeError
-- empty array → returns []
-- value > MAX_INT → clamps to MAX_INT
-```
-
-## Communication
-- Reports findings to: orchestrator (characterization-test skill)
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-Focus on observable contracts, not implementation internals. Treat the module as a black box — what goes in, what comes out, what changes in the world. Use `toMatchSnapshot()` candidates for complex return shapes.

package/skills/characterization-test/agents/coverage-checker.md

@@ -1,54 +0,0 @@
----
-name: coverage-checker
-role: Verifies all public methods and edge cases are covered by characterization tests
-tools: [Read, Bash, Grep]
----
-
-# Coverage Checker
-
-## Role
-Audits the generated characterization test file against the behavior manifest to confirm every public method, branch path, and identified edge case has a corresponding locked test. Flags gaps before the refactor begins.
-
-## Responsibilities
-- Cross-reference every public function in the manifest against test cases
-- Verify each branching path has at least one test
-- Confirm edge cases (null, empty, boundary) are all exercised
-- Run the test suite and confirm all tests pass with current code
-- Report any uncovered paths as blockers
-
-## Input
-- Behavior manifest from behavior-capturer
-- Generated test file path from test-writer
-- Project root path for running vitest
-
-## Output
-Coverage audit report:
-
-```markdown
-## Coverage Audit: {ModuleName}
-
-### Public Methods
-- functionA: covered (3 tests)
-- functionB: MISSING — no test found
-
-### Branch Paths
-- functionA happy path: covered
-- functionA null branch: covered
-- functionB error branch: MISSING
-
-### Edge Cases
-- empty string: covered
-- null input: covered
-- value > MAX: MISSING
-
-### Test Run Result
-- Passed: 12 / Failed: 0
-- Uncovered items: 2 (must fix before refactor)
-```
-
-## Communication
-- Reports findings to: orchestrator (characterization-test skill)
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-Any MISSING item is a blocker — refactor must not start until all identified behaviors are locked. Re-run test-writer for gap items rather than patching manually.

package/skills/characterization-test/agents/reporter.md

@@ -1,50 +0,0 @@
----
-name: reporter
-role: Summarizes what behavior is locked and confirms the codebase is safe to refactor
-tools: [Read, Bash]
----
-
-# Reporter
-
-## Role
-Produces the final summary after all characterization tests pass. Communicates to the developer exactly what is now locked, what is not covered, and what the safe refactoring boundaries are.
-
-## Responsibilities
-- Summarize total test count and what behaviors each test locks
-- List any intentionally excluded behaviors and the rationale
-- State explicit refactor safety boundaries (what can change vs. what must stay)
-- Provide the single command to run before and after any code change
-- Archive the behavior manifest alongside the test file
-
-## Input
-- Coverage audit report from coverage-checker
-- Final test run results
-- Original behavior manifest
-
-## Output
-A handoff summary printed to the user:
-
-```markdown
-## Characterization Test Report: {ModuleName}
-
-### Locked Behaviors (safe to refactor)
-- functionA: 3 cases locked (happy path, null, empty array)
-- functionB: 2 cases locked (returns string, throws on invalid)
-
-### Not Covered (refactor with caution)
-- functionC: no tests — side effects unclear, manual review required
-
-### Refactor Safety Command
-Run this before AND after changes:
-  npx vitest run src/__tests__/{module}.characterization.test.ts
-
-### Verdict
-SAFE TO REFACTOR — all public API surface locked.
-```
-
-## Communication
-- Reports findings to: user / orchestrator
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-A green characterization suite is a contract. Any failure after refactor means behavior changed — intentional or not. Distinguish between "expected failures" (intended changes) and "unexpected failures" (regressions).

package/skills/characterization-test/agents/test-writer.md

@@ -1,49 +0,0 @@
----
-name: test-writer
-role: Generates vitest characterization tests that lock captured behavior
-tools: [Read, Write, Edit, Bash]
----
-
-# Test Writer
-
-## Role
-Takes the behavior manifest from behavior-capturer and produces a complete vitest test file that locks the current behavior as-is. Tests capture actual output — not expected behavior — using snapshot assertions.
-
-## Responsibilities
-- Write one `describe` block per module with clearly labeled test cases
-- Cover every branching path identified in the behavior manifest
-- Use `toMatchSnapshot()` for complex return shapes, `toBe`/`toEqual` for primitives
-- Include error path tests with `toThrowErrorMatchingSnapshot()`
-- Never fix bugs — lock current behavior exactly as it is
-
-## Input
-- Behavior manifest from behavior-capturer
-- Target file path(s) and their import shapes
-- Project test config (vitest.config.ts location)
-
-## Output
-A complete test file written to `src/__tests__/{module}.characterization.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { targetFn } from '../path/to/module.js';
-
-describe('{ModuleName} characterization tests', () => {
-  it('should handle normal input', () => {
-    expect(targetFn(normalInput)).toMatchSnapshot();
-  });
-
-  it('should handle null input', () => {
-    expect(() => targetFn(null)).toThrowErrorMatchingSnapshot();
-  });
-});
-```
-
-Reports: path to generated test file and count of test cases written.
-
-## Communication
-- Reports findings to: orchestrator (characterization-test skill)
-- Receives instructions from: orchestrator
-
-## Domain Knowledge
-Characterization test rule: if the current code returns a wrong value for an input, the test must lock THAT wrong value. The goal is regression detection, not correctness. Use `vitest --run -u` to initialize snapshots on first run.

package/skills/characterization-test/rubrics/coverage-criteria.md

@@ -1,53 +0,0 @@
-# Characterization Test Coverage Criteria
-
-Coverage that MUST exist before any refactoring begins.
-
-## Mandatory Coverage (all must pass before changing code)
-
-### Public API Surface
-- [ ] Every exported function has at least one characterization test
-- [ ] Every exported class method (public) has at least one test
-- [ ] Every exported type's runtime behavior is tested where applicable
-
-### Input Coverage
-- [ ] Typical / happy-path input
-- [ ] Minimum valid input (empty string, 0, `[]`, `{}`)
-- [ ] Maximum or large input (long strings, large arrays)
-- [ ] Boundary values (off-by-one, limits)
-
-### Branch Coverage
-- [ ] Each top-level `if` branch has a dedicated test
-- [ ] Each `switch` case has a dedicated test
-- [ ] `try/catch` — both success and error paths tested
-- [ ] Short-circuit conditions (`&&`, `||`) exercised
-
-### Error Paths
-- [ ] `null` input behavior captured
-- [ ] `undefined` input behavior captured
-- [ ] Invalid type input behavior captured
-- [ ] Thrown errors match snapshot (message, type)
-
-### Side Effects
-- [ ] External calls (DB, network, filesystem) are mocked and call args verified
-- [ ] Return values from mocks are representative of real responses
-- [ ] State mutations are verified before and after
-
-## Sufficient vs. Insufficient Coverage
-
-| Situation | Sufficient? |
-|-----------|-------------|
-| 1 happy-path snapshot only | No — missing edge cases and error paths |
-| All branches covered, no error paths | No — error behavior must be locked |
-| All public exports tested | Minimum viable — add side-effect tests if any exist |
-| Snapshot exists but test not run | No — must run and pass before refactoring |
-| Test passes after code change | Confirm intentional; update snapshot with reason |
-
-## Definition of Done
-
-The characterization suite is complete when:
-
-1. All tests pass on current code without modification
-2. Every public export is exercised
-3. At least one error-path test exists per function
-4. Snapshots are committed alongside tests
-5. `npx vitest run <test-file>` exits with code 0

package/skills/characterization-test/templates/test-template.ts

@@ -1,101 +0,0 @@
-/**
- * Characterization test template — lock existing behavior before refactoring.
- *
- * Instructions:
- *   1. Replace {{MODULE_NAME}} with the module under test.
- *   2. Replace {{IMPORT_PATH}} with the relative import path.
- *   3. Replace {{FUNCTION_NAME}} with each public export to characterize.
- *   4. Run once to generate snapshots: npx vitest run --update {{TEST_FILE}}
- *   5. Verify all tests pass BEFORE making any changes to the source.
- *
- * IMPORTANT: Capture ACTUAL behavior, not expected/ideal behavior.
- * If the current code has a bug, capture the buggy output — fix it separately.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// import { {{FUNCTION_NAME}} } from '{{IMPORT_PATH}}';
-
-describe('{{MODULE_NAME}} — characterization tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  // -------------------------------------------------------------------------
-  // Happy path — normal inputs
-  // -------------------------------------------------------------------------
-
-  it('should handle typical input', () => {
-    // const result = {{FUNCTION_NAME}}({{TYPICAL_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle minimum valid input', () => {
-    // const result = {{FUNCTION_NAME}}({{MIN_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle maximum valid input', () => {
-    // const result = {{FUNCTION_NAME}}({{MAX_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  // -------------------------------------------------------------------------
-  // Edge cases — boundary values
-  // -------------------------------------------------------------------------
-
-  it('should handle empty string input', () => {
-    // const result = {{FUNCTION_NAME}}('');
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle empty array input', () => {
-    // const result = {{FUNCTION_NAME}}([]);
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should handle zero / false / null-like values', () => {
-    // const result = {{FUNCTION_NAME}}(0);
-    // expect(result).toMatchSnapshot();
-  });
-
-  // -------------------------------------------------------------------------
-  // Error paths — failure modes
-  // -------------------------------------------------------------------------
-
-  it('should handle null input', () => {
-    // expect(() => {{FUNCTION_NAME}}(null)).toThrowErrorMatchingSnapshot();
-  });
-
-  it('should handle undefined input', () => {
-    // expect(() => {{FUNCTION_NAME}}(undefined)).toThrowErrorMatchingSnapshot();
-  });
-
-  it('should handle invalid type input', () => {
-    // expect(() => {{FUNCTION_NAME}}({{INVALID_INPUT}})).toThrowErrorMatchingSnapshot();
-  });
-
-  // -------------------------------------------------------------------------
-  // Side effects — external interactions
-  // -------------------------------------------------------------------------
-
-  it('should call external dependency with correct arguments', () => {
-    // const spy = vi.spyOn({{DEPENDENCY}}, '{{METHOD}}');
-    // {{FUNCTION_NAME}}({{TYPICAL_INPUT}});
-    // expect(spy).toHaveBeenCalledWith({{EXPECTED_ARGS}});
-    // expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  // -------------------------------------------------------------------------
-  // Branching paths — one test per major branch
-  // -------------------------------------------------------------------------
-
-  it('should take branch A when condition is true', () => {
-    // const result = {{FUNCTION_NAME}}({{BRANCH_A_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-
-  it('should take branch B when condition is false', () => {
-    // const result = {{FUNCTION_NAME}}({{BRANCH_B_INPUT}});
-    // expect(result).toMatchSnapshot();
-  });
-});