@harness-engineering/cli 1.14.0 → 1.16.0

package/dist/agents/skills/cursor/harness-tdd/SKILL.md

@@ -0,0 +1,177 @@
+# Harness TDD
+
+> Red-green-refactor cycle integrated with harness validation. No production code exists without a failing test first.
+
+## When to Use
+
+- Implementing any new feature, function, module, or component
+- Fixing any bug (write a test that reproduces the bug first)
+- Adding behavior to existing code
+- When `on_new_feature` or `on_bug_fix` triggers fire
+- NOT when doing pure refactoring with existing test coverage (use harness-refactoring instead)
+- NOT when writing documentation, configuration, or non-behavioral files
+- NOT when spiking/prototyping (but convert spikes to TDD before merging)
+
+## Process
+
+### Iron Law
+
+**No production code may exist without a failing test that demanded its creation.**
+
+If you find yourself writing production code first, STOP. Delete it. Write the test first. This is not a guideline — it is a hard constraint.
+
+### Phase 1: RED — Write a Failing Test
+
+1. **Identify the smallest behavior to test.** One assertion per test. One behavior per cycle. If you are testing two things, split into two cycles.
+
+2. **Write the test file or add to the appropriate test file.** Follow the project's existing test conventions (file naming, framework, location).
+
+3. **Write ONE minimal test** that asserts the expected behavior. The test should:
+   - Have a clear, descriptive name that states what behavior is expected
+   - Set up only the minimal fixtures needed
+   - Make a single assertion about the expected outcome
+   - NOT test implementation details — test observable behavior
+
+4. **Run the test suite.** Use the project's test runner (e.g., `npx vitest run path/to/test`, `npm test`, `pytest`).
+
+5. **MANDATORY: Watch the test FAIL.** Read the failure message. Confirm it fails for the RIGHT reason — the behavior is not yet implemented, not because the test is broken. If the test passes, either the behavior already exists (skip this cycle) or the test is wrong (fix the test).
+
+6. **Record the failure.** Note the test name and failure reason. This is your contract for the GREEN phase.
+
+### Phase 2: GREEN — Write the Simplest Code to Pass
+
+1. **Write the MINIMUM production code** that makes the failing test pass. Do not write code for future tests. Do not add error handling you have not tested. Do not generalize.
+
+2. **Resist the urge to write "good" code.** The GREEN phase is about correctness, not elegance. Hardcoded values are acceptable if they pass the test. Duplication is acceptable. You will clean up in REFACTOR.
+
+3. **Run the FULL test suite** (not just the new test). All tests must pass.
+
+4. **MANDATORY: Watch the test PASS.** Read the output. Confirm all tests are green. If any test fails, fix the production code (not the tests) until all pass.
+
+5. **Do not proceed to REFACTOR if any test is red.** Fix first.
+
+### Phase 3: REFACTOR — Clean Up While Green
+
+1. **With all tests passing,** look for opportunities to improve:
+   - Remove duplication (DRY)
+   - Extract methods or functions for clarity
+   - Rename for better readability
+   - Simplify conditionals
+   - Improve structure without changing behavior
+
+2. **Run the full test suite after EVERY change.** If a test breaks during refactoring, undo the last change immediately. Refactoring must not change behavior.
+
+3. **Keep refactoring steps small.** One rename, one extraction, one simplification at a time. Run tests between each.
+
+4. **If no refactoring is needed, skip this phase.** Not every cycle requires cleanup.
+
+### Phase 4: VALIDATE — Run Harness Checks
+
+1. **Run `harness check-deps`** to verify dependency boundaries are respected. New code must not introduce forbidden imports or layer violations.
+
+2. **Run `harness validate`** to verify the full project health. This catches architectural drift, documentation gaps, and constraint violations.
+
+3. **If either check fails,** fix the issue before committing. The fix may require another RED-GREEN-REFACTOR cycle if it involves behavioral changes.
+
+4. **Commit the cycle.** Each RED-GREEN-REFACTOR-VALIDATE cycle produces one atomic commit. The commit message references what behavior was added (not "add test" — describe the behavior).
+
+### Graph Refresh
+
+If a knowledge graph exists at `.harness/graph/`, refresh it after code changes to keep graph queries accurate:
+
+```
+harness scan [path]
+```
+
+Skipping this step means subsequent graph queries (impact analysis, dependency health, test advisor) may return stale results.
+
+### Cycle Rhythm
+
+Repeat the 4 phases for each new behavior. A typical feature requires 3-10 cycles. Each cycle should take 2-15 minutes. If a cycle takes longer than 15 minutes, the step is too large — break it down.
+
+**Ordering within a feature:**
+
+1. Start with the happy path (simplest success case)
+2. Add edge cases one at a time
+3. Add error handling cases
+4. Add integration points last
+
+## Harness Integration
+
+- **`harness check-deps`** — Run in VALIDATE phase after each cycle. Catches forbidden imports and layer boundary violations introduced by new code.
+- **`harness validate`** — Run in VALIDATE phase after each cycle. Full project health check including architecture, documentation, and constraints.
+- **`harness cleanup`** — Run periodically (every 3-5 cycles) to detect entropy accumulation. Address any issues before they compound.
+- **Test runner** — Use the project's configured test runner. Harness does not prescribe a test framework but the test must actually execute and report results.
+
+## Success Criteria
+
+- Every production function/method has at least one corresponding test
+- Every test was observed to fail before the production code was written
+- Every test was observed to pass after the production code was written
+- `harness check-deps` passes after each cycle
+- `harness validate` passes after each cycle
+- Each cycle is an atomic commit with a descriptive message
+- No test tests implementation details (only observable behavior)
+- No production code exists that was not demanded by a failing test
+
+## Examples
+
+### Example: Adding a `calculateTotal` function
+
+**RED:**
+
+```typescript
+// cart.test.ts
+it('calculates total for items with quantity and price', () => {
+  const items = [
+    { name: 'Widget', price: 10, quantity: 2 },
+    { name: 'Gadget', price: 25, quantity: 1 },
+  ];
+  expect(calculateTotal(items)).toBe(45);
+});
+```
+
+Run tests. Observe: `ReferenceError: calculateTotal is not defined`. Correct failure — function does not exist yet.
+
+**GREEN:**
+
+```typescript
+// cart.ts
+export function calculateTotal(items: Array<{ price: number; quantity: number }>): number {
+  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+}
+```
+
+Run tests. Observe: all tests pass.
+
+**REFACTOR:** No refactoring needed for this simple function. Skip.
+
+**VALIDATE:**
+
+```bash
+harness check-deps   # Pass
+harness validate     # Pass
+git add cart.ts cart.test.ts
+git commit -m "feat(cart): calculate total from item price and quantity"
+```
+
+**Next cycle (RED):** Write a test for empty array input. Watch it fail (or pass — if it passes, the behavior is already handled). Continue.
+
+## Gates
+
+These are hard stops. Violating any gate means the process has broken down.
+
+- **Code before test = delete it.** If production code is written before a failing test exists, delete the production code and start the cycle correctly.
+- **Must watch fail.** If you did not observe the test fail with the correct failure reason, the RED phase is incomplete. Do not proceed to GREEN.
+- **Must watch pass.** If you did not observe all tests pass after writing production code, the GREEN phase is incomplete. Do not proceed to REFACTOR.
+- **No skipping VALIDATE.** Every cycle must end with `harness check-deps` and `harness validate`. Skipping creates architectural debt that compounds.
+- **No multi-behavior tests.** One test, one assertion, one behavior. Tests that assert multiple unrelated things must be split.
+- **No "I'll write tests later."** There is no later. The test comes first or the code does not get written.
+
+## Escalation
+
+- **After 3 failed attempts to make a test pass:** Stop coding. The design may be wrong. Re-examine the interface, the test assumptions, or the architecture. Consider whether the feature needs a different approach. Consult the plan or spec.
+- **When a test cannot be written without complex mocking:** This is a design smell. The code under test has too many dependencies. Refactor the existing code to be more testable before proceeding, or reconsider the abstraction boundary.
+- **When harness checks repeatedly fail:** The new code may be violating architectural constraints intentionally. Escalate to the human to decide whether to update the constraints or change the approach.
+- **When the cycle is taking more than 15 minutes:** The step is too large. Break the current behavior into smaller sub-behaviors and test each one separately.
+- **When you are unsure what to test next:** Review the spec or plan. If no spec exists, use the harness-brainstorming skill to clarify requirements before writing more tests.

package/dist/agents/skills/cursor/harness-tdd/skill.yaml

@@ -0,0 +1,49 @@
+name: harness-tdd
+version: "1.0.0"
+description: Test-driven development integrated with harness validation
+cognitive_mode: meticulous-implementer
+triggers:
+  - manual
+  - on_new_feature
+  - on_bug_fix
+platforms:
+  - claude-code
+  - gemini-cli
+tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+cli:
+  command: harness skill run harness-tdd
+  args:
+    - name: path
+      description: Project root path
+      required: false
+mcp:
+  tool: run_skill
+  input:
+    skill: harness-tdd
+    path: string
+type: rigid
+tier: 1
+phases:
+  - name: red
+    description: Write failing test
+    required: true
+  - name: green
+    description: Implement minimal code to pass
+    required: true
+  - name: refactor
+    description: Clean up while keeping tests green
+    required: false
+  - name: validate
+    description: Run harness checks
+    required: true
+state:
+  persistent: false
+  files: []
+depends_on:
+  - harness-verification

package/dist/agents/skills/cursor/harness-test-advisor/SKILL.md

@@ -0,0 +1,160 @@
+# Harness Test Advisor
+
+> Graph-based test selection. Answers: "I changed these files — what tests should I run?"
+
+## When to Use
+
+- Before pushing code — run only the tests that matter
+- In CI — optimize test suite execution order
+- When a test fails — understand which changes could have caused it
+- When `on_pr` triggers fire
+- NOT for writing tests (use harness-tdd)
+- NOT for test quality analysis (out of scope)
+
+## Prerequisites
+
+A knowledge graph at `.harness/graph/` enables full analysis. If no graph exists,
+the skill uses static analysis fallbacks (see Graph Availability section).
+Run `harness scan` to enable graph-enhanced analysis.
+
+### Graph Availability
+
+Before starting, check if `.harness/graph/graph.json` exists.
+
+**If graph exists:** Check staleness — compare `.harness/graph/metadata.json`
+scanTimestamp against `git log -1 --format=%ct` (latest commit timestamp).
+If graph is more than 10 commits behind (`git log --oneline <scanTimestamp>..HEAD | wc -l`),
+run `harness scan` to refresh before proceeding. (Staleness sensitivity: **Medium**)
+
+**If graph exists and is fresh (or refreshed):** Use graph tools as primary strategy.
+
+**If no graph exists:** Output "Running without graph (run `harness scan` to
+enable full analysis)" and use fallback strategies for all subsequent steps.
+
+## Process
+
+### Phase 1: PARSE — Identify Changed Files
+
+1. **From diff**: Parse `git diff --name-only` to get changed file paths.
+2. **From input**: Accept comma-separated file paths.
+3. **Filter**: Only consider `.ts`, `.tsx`, `.js`, `.jsx` files (skip docs, config).
+
+### Phase 2: DISCOVER — Find Related Tests via Graph
+
+For each changed file, use graph traversal to find test files:
+
+1. **Direct test coverage**: Use `get_impact` to find test files that import the changed file.
+
+   ```
+   get_impact(filePath="src/services/auth.ts")
+   → tests: ["tests/services/auth.test.ts", "tests/integration/auth-flow.test.ts"]
+   ```
+
+2. **Transitive test coverage**: Use `query_graph` with depth 2 to find tests that import files that import the changed file.
+
+   ```
+   query_graph(rootNodeIds=["file:src/services/auth.ts"], maxDepth=2, includeEdges=["imports"], bidirectional=true)
+   ```
+
+3. **Co-change tests**: Check `co_changes_with` edges for test files that historically change alongside the modified files.
+
+#### Fallback (without graph)
+
+When no graph is available, use naming conventions, import parsing, and git history:
+
+1. **Tier 1 — Filename convention matching**: For each changed file `foo.ts`, search for:
+   - `foo.test.ts`, `foo.spec.ts` (same directory)
+   - `__tests__/foo.ts`, `__tests__/foo.test.ts`
+   - Test files in a parallel `tests/` directory mirroring the source path
+2. **Tier 2 — Import-linked tests**: Parse test files' import statements (grep for `import.*from` in `*.test.*` and `*.spec.*` files). If a test file imports the changed file, it belongs in Tier 2 (if not already in Tier 1).
+3. **Tier 3 — Co-change correlated tests**: Use `git log --format="%H" --name-only` to find test files that frequently change in the same commit as the target file. Files that co-change in >2 commits are co-change correlated.
+4. **Rank**: Tier 1 = direct filename match, Tier 2 = import-linked tests, Tier 3 = co-change correlated tests. Output the same tiered format as the graph version.
+
+> Fallback completeness: ~80% — naming conventions and imports catch most mappings; misses dynamic imports and indirect coverage.
+
+### Phase 3: PRIORITIZE — Rank and Generate Commands
+
+Organize tests into three tiers:
+
+**Tier 1 — Must Run** (direct coverage):
+Tests that directly import or test the changed files. These are most likely to catch regressions.
+
+**Tier 2 — Should Run** (transitive coverage):
+Tests that cover code one hop away from the changed files. These catch indirect breakage.
+
+**Tier 3 — Could Run** (related):
+Tests in the same module or that co-change with the modified files. Lower probability of failure but worth running if time permits.
+
+### Output
+
+```
+## Test Advisor Report
+
+### Changed Files
+- src/services/auth.ts (modified)
+- src/types/user.ts (modified)
+
+### Tier 1 — Must Run (direct coverage)
+1. tests/services/auth.test.ts — imports auth.ts
+2. tests/types/user.test.ts — imports user.ts
+
+### Tier 2 — Should Run (transitive)
+3. tests/routes/login.test.ts — imports routes/login.ts → imports auth.ts
+4. tests/middleware/verify.test.ts — imports middleware/verify.ts → imports auth.ts
+
+### Tier 3 — Could Run (related)
+5. tests/integration/auth-flow.test.ts — same module, co-changes with auth.ts
+
+### Quick Run Command
+npx vitest run tests/services/auth.test.ts tests/types/user.test.ts tests/routes/login.test.ts tests/middleware/verify.test.ts
+
+### Full Run Command (all tiers)
+npx vitest run tests/services/auth.test.ts tests/types/user.test.ts tests/routes/login.test.ts tests/middleware/verify.test.ts tests/integration/auth-flow.test.ts
+```
+
+## Harness Integration
+
+- **`harness scan`** — Recommended before this skill for full graph-enhanced analysis. If graph is missing, skill uses naming convention and import parsing fallbacks.
+- **`harness validate`** — Run after acting on findings to verify project health.
+- **Graph tools** — This skill uses `query_graph`, `get_impact`, and `get_relationships` MCP tools.
+
+## Success Criteria
+
+- Tests prioritized into 3 tiers (Must Run, Should Run, Could Run)
+- Executable run commands generated for quick and full test runs
+- Coverage gaps flagged for changed files with no test coverage
+- Report follows the structured output format
+- All findings are backed by graph query evidence (with graph) or systematic static analysis (without graph)
+
+## Examples
+
+### Example: Selecting Tests for a Services Change
+
+```
+Input: git diff shows src/services/auth.ts and src/types/user.ts modified
+
+1. PARSE    — 2 changed files identified (both .ts)
+2. DISCOVER — get_impact(filePath="src/services/auth.ts")
+              query_graph with depth 2 for transitive tests
+              Tier 1: auth.test.ts, user.test.ts (direct imports)
+              Tier 2: login.test.ts, verify.test.ts (one hop away)
+              Tier 3: auth-flow.test.ts (co-change history)
+3. PRIORITIZE — 5 tests across 3 tiers
+
+Output:
+  Tier 1 (must run): 2 tests
+  Tier 2 (should run): 2 tests
+  Tier 3 (could run): 1 test
+  Quick command: npx vitest run auth.test.ts user.test.ts login.test.ts verify.test.ts
+  Coverage gaps: none
+```
+
+## Gates
+
+- **Graph preferred, fallback available.** If no graph exists, use naming conventions, import parsing, and git co-change analysis to identify relevant tests. Do not stop — produce the best test selection possible.
+- **Always include Tier 1.** Direct test coverage is non-negotiable — always recommend running these (whether found via graph or naming conventions).
+
+## Escalation
+
+- **When changed file has no test coverage**: Flag as a gap: "No tests found for src/services/auth.ts — consider adding tests before merging."
+- **When Tier 1 has >20 tests**: The changed file may be a hub. Suggest running Tier 1 in parallel or splitting the file.

package/dist/agents/skills/cursor/harness-test-advisor/skill.yaml

@@ -0,0 +1,45 @@
+name: harness-test-advisor
+version: "1.0.0"
+description: Graph-based test selection — answers "what tests should I run?"
+cognitive_mode: advisory-guide
+triggers:
+  - manual
+  - on_pr
+platforms:
+  - claude-code
+  - gemini-cli
+tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+cli:
+  command: harness skill run harness-test-advisor
+  args:
+    - name: path
+      description: Project root path
+      required: false
+    - name: files
+      description: Comma-separated list of changed files
+      required: false
+mcp:
+  tool: run_skill
+  input:
+    skill: harness-test-advisor
+    path: string
+type: flexible
+tier: 2
+phases:
+  - name: parse
+    description: Identify changed files from diff or input
+    required: true
+  - name: discover
+    description: Find related tests via graph traversal
+    required: true
+  - name: prioritize
+    description: Rank tests by relevance and generate commands
+    required: true
+state:
+  persistent: false
+  files: []
+depends_on: []