intentdna 1.5.8 → 1.5.10

package/dist/templates/root-cause-analysis.dna.yaml

@@ -0,0 +1,140 @@
+version: "0.1.0"
+id: template_root_cause_analysis
+name: Root Cause Analysis (Competing Hypotheses)
+type: project
+namespace: rca
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  multiple_hypotheses:
+    description: Always generate multiple competing hypotheses before investigating
+    codons:
+      - type: threshold
+        condition: "hypotheses_count >= 3"
+        action: block
+      - type: attract
+        target: generate_alternatives
+      - type: repel
+        target: single_theory_bias
+
+  falsify_own:
+    description: Actively try to disprove your own hypotheses
+    codons:
+      - type: attract
+        target: seek_disconfirming_evidence
+      - type: repel
+        target: confirmation_bias
+      - type: threshold
+        condition: "each_hypothesis_has_counter_evidence == true"
+        action: escalate
+
+  evidence_ranked:
+    description: Rank evidence by strength and reliability
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: grade_evidence_quality
+      - type: attract
+        target: distinguish_correlation_causation
+
+  minimal_reproduction:
+    description: Create minimal reproduction before investigating
+    codons:
+      - type: attract
+        target: reproduce_before_hypothesizing
+      - type: repel
+        target: guess_without_evidence
+
+contexts: {}
+
+roles:
+  hypothesis_generator:
+    description: Generates competing hypotheses from symptoms. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Read error messages, logs, and stack traces
+      - Generate at least 3 competing hypotheses
+      - For each hypothesis state what evidence would confirm AND refute it
+      - Rank by prior probability (most likely first)
+      - Do NOT suggest fixes yet
+
+  investigator:
+    description: Gathers evidence for/against each hypothesis. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Test each hypothesis by gathering specific evidence
+      - For each hypothesis record evidence FOR and AGAINST
+      - Try to DISPROVE the leading hypothesis first
+      - Use git blame, logs, test output as evidence
+      - Grade evidence strength (strong/moderate/weak)
+      - After investigation rank hypotheses by evidence weight
+
+workflows:
+  root-cause:
+    name: Root Cause Analysis
+    description: "Competing hypotheses debugging: hypothesize, investigate, rank, synthesize"
+    steps:
+      - id: reproduce
+        role: investigator
+        description: "Reproduce the issue and collect symptoms."
+        prompt: |
+          Reproduce the reported issue:
+          1. Run the failing test or trigger the bug
+          2. Collect all symptoms: error messages, stack traces, logs
+          3. Note: when did it start? What changed recently? (git log)
+          4. Output: symptom summary + reproduction steps
+
+      - id: hypothesize
+        role: hypothesis_generator
+        depends_on: [reproduce]
+        description: "Generate 3+ competing hypotheses."
+        prompt: |
+          Based on the symptoms, generate at least 3 competing hypotheses:
+          For each hypothesis:
+          - Statement: what is the root cause?
+          - Prior probability: how likely (high/medium/low)?
+          - Confirming evidence: what would prove this?
+          - Refuting evidence: what would disprove this?
+          - Quick test: what's the fastest way to check?
+
+          Order by prior probability. Do NOT investigate yet.
+
+      - id: investigate
+        role: investigator
+        depends_on: [hypothesize]
+        description: "Gather evidence for/against each hypothesis."
+        prompt: |
+          For each hypothesis, gather evidence:
+          1. Run the quick test suggested
+          2. Check code paths, git blame, recent changes
+          3. Record evidence FOR and AGAINST each hypothesis
+          4. Grade evidence strength: strong / moderate / weak
+          5. Try hardest to DISPROVE the leading hypothesis
+
+          After all evidence gathered, rank hypotheses by total evidence weight.
+
+      - id: synthesize
+        role: hypothesis_generator
+        depends_on: [investigate]
+        description: "Determine root cause and recommend fix."
+        prompt: |
+          Based on evidence:
+          1. Which hypothesis has the strongest evidence?
+          2. Which hypotheses were refuted?
+          3. Are there any remaining unknowns?
+          4. Root cause determination (with confidence level)
+          5. Recommended fix approach
+          6. What regression test would prevent recurrence?

package/dist/templates/systematic-debugging.dna.yaml

@@ -53,4 +53,98 @@ genes:
         condition: "bugfix_without_test == false"
         action: block
 
+  competing_hypotheses:
+    description: Always consider multiple possible causes
+    codons:
+      - type: threshold
+        condition: "hypotheses_count >= 2"
+        action: escalate
+      - type: attract
+        target: consider_alternative_explanations
+      - type: repel
+        target: jump_to_first_theory
+
 contexts: {}
+
+roles:
+  hypothesis_generator:
+    description: Generates competing debugging hypotheses. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Read error messages, logs, stack traces
+      - Generate at least 2 competing hypotheses
+      - For each hypothesis state confirming and refuting evidence
+      - Rank by likelihood
+      - Do NOT suggest fixes
+
+  debugger:
+    description: Investigates hypotheses and applies fixes.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**", "test/**"]
+    instructions:
+      - Test each hypothesis systematically
+      - Start with the most likely hypothesis
+      - Use git bisect, logging, and targeted tests
+      - When root cause found apply minimal fix
+      - Write regression test before fixing
+      - Run tests after fix
+
+workflows:
+  debug-with-hypotheses:
+    name: Debug with Hypotheses
+    description: "Hypothesis-driven debugging: hypothesize, investigate, fix, verify"
+    steps:
+      - id: hypothesize
+        role: hypothesis_generator
+        description: "Generate competing hypotheses from symptoms."
+        prompt: |
+          Analyze the bug symptoms:
+          1. Reproduce the issue
+          2. Collect error messages, logs, stack traces
+          3. Check recent git changes
+          4. Generate at least 2 competing hypotheses
+          5. For each: what evidence would confirm? What would refute?
+          6. Rank by likelihood
+
+      - id: investigate
+        role: debugger
+        depends_on: [hypothesize]
+        description: "Test hypotheses and find root cause."
+        prompt: |
+          Test each hypothesis:
+          1. Start with most likely
+          2. Gather targeted evidence (add logging, run specific tests)
+          3. If confirmed → proceed to fix
+          4. If refuted → move to next hypothesis
+          5. Record evidence for each hypothesis tested
+
+      - id: fix
+        role: debugger
+        depends_on: [investigate]
+        description: "Apply minimal fix and write regression test."
+        prompt: |
+          Fix the confirmed root cause:
+          1. Write a regression test that reproduces the bug FIRST
+          2. Apply the minimal fix
+          3. Verify the regression test passes
+          4. Run full test suite for regressions
+          5. Commit: "fix: [description] — root cause: [what and why]"
+
+      - id: verify
+        role: hypothesis_generator
+        depends_on: [fix]
+        description: "Verify fix is correct and complete."
+        prompt: |
+          Verify the fix:
+          1. Is the root cause actually addressed (not just symptoms)?
+          2. Does the regression test cover the exact failure mode?
+          3. Any related code paths that might have the same issue?
+          4. Verdict: VERIFIED or INCOMPLETE

package/dist/templates/tdd-strict.dna.yaml

@@ -52,19 +52,103 @@ genes:
 contexts: {}
 
 roles:
+  test_writer:
+    description: Writes failing tests before implementation. Can create test files.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["test/**", "tests/**", "spec/**", "__tests__/**"]
+    instructions:
+      - Write the test FIRST — it must fail initially (red phase)
+      - Test should describe the desired behavior, not the implementation
+      - One test case per behavior
+      - Run the test to confirm it fails for the right reason
+      - Do NOT write implementation code
+
   implementer:
-    description: TDD implementer — writes tests first, then code
+    description: Writes minimal code to make tests pass.
     tool_permissions:
       allow: [Read, Edit, Write, Grep, Glob, Bash]
     scope:
       read: ["**/*"]
-      write: ["src/**", "test/**"]
+      write: ["src/**", "lib/**"]
     instructions:
-      - Always write the failing test FIRST
-      - Run the test to confirm it fails (red)
-      - Write the minimum code to make it pass (green)
-      - Refactor if needed, keeping tests green
-      - Never commit with failing tests
-    post_checks:
-      - vitest_run
-      - tsc_no_errors
+      - Write the MINIMUM code to make the failing test pass (green phase)
+      - Do not add extra functionality beyond what the test requires
+      - Do not optimize or clean up code yet
+      - Run the test after each change to verify it passes
+      - Do not modify test files
+
+  refactorer:
+    description: Cleans up code while keeping tests green.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**"]
+    instructions:
+      - Clean up the implementation (refactor phase)
+      - Run ALL tests after each refactoring step
+      - If any test breaks, revert immediately
+      - Focus on readability, removing duplication, improving naming
+      - Do NOT add new functionality during refactoring
+      - Do NOT modify test files
+
+workflows:
+  tdd-cycle:
+    name: TDD Cycle
+    description: "Red-Green-Refactor: write failing test, implement minimally, clean up"
+    steps:
+      - id: write_test
+        role: test_writer
+        description: "Write a failing test for the desired behavior (RED)."
+        prompt: |
+          TDD Red Phase:
+          1. Understand the behavior to implement
+          2. Write ONE test that describes this behavior
+          3. Run the test — it MUST fail
+          4. Verify it fails for the right reason (not a syntax error)
+          5. Commit: "test: add failing test for [behavior]"
+
+          Do NOT write any implementation code.
+
+      - id: implement
+        role: implementer
+        depends_on: [write_test]
+        description: "Write minimal code to pass the test (GREEN)."
+        prompt: |
+          TDD Green Phase:
+          1. Read the failing test carefully
+          2. Write the MINIMUM code to make it pass
+          3. Run the test — it must pass now
+          4. Run the full test suite — no regressions
+          5. Commit: "feat: implement [behavior] — test green"
+
+          Rules:
+          - Do NOT add code beyond what the test requires
+          - Do NOT optimize yet
+          - Do NOT modify test files
+
+      - id: refactor
+        role: refactorer
+        depends_on: [implement]
+        description: "Clean up code while keeping all tests green (REFACTOR)."
+        prompt: |
+          TDD Refactor Phase:
+          1. Review the implementation for code smells
+          2. Apply ONE refactoring at a time
+          3. Run ALL tests after each change
+          4. If any test breaks: REVERT immediately
+          5. Commit: "refactor: [what was cleaned up]"
+
+          Focus on:
+          - Remove duplication
+          - Improve naming
+          - Simplify logic
+          - Extract methods/functions if needed
+
+          Do NOT:
+          - Add new features
+          - Modify test files
+          - Change behavior

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",