@su-record/vibe 2.16.3 → 3.0.0

package/hooks/scripts/keyword-detector.js

@@ -1,226 +0,0 @@
-#!/usr/bin/env node
-/**
- * Keyword Detector & Combiner
- * 매직 키워드 감지 및 조합 처리
- */
-
-import { VIBE_PATH, PROJECT_DIR } from './utils.js';
-
-// 매직 키워드 정의
-const MAGIC_KEYWORDS = {
-  // Deprecated: 기본 루프 동작과 동일 (no-op). exit=coverage-100으로 해석.
-  ralph: {
-    name: 'Ralph (deprecated alias)',
-    description: '[deprecated] Looping to convergence is the default; alias mapped',
-    flags: ['persistence', 'verification'],
-    output: '[vibe] \'ralph\' is deprecated — looping to convergence is the default; alias mapped.',
-  },
-
-  // 울트라워크 모드 (automationLevel: autonomous + 병렬 ACT)
-  ultrawork: {
-    name: 'Ultrawork',
-    description: 'automationLevel: autonomous + parallel ACT (deprecated alias)',
-    flags: ['parallel', 'auto_continue', 'no_confirmation'],
-    output: '[ULTRAWORK] automationLevel: autonomous + parallel ACT. Loop runs to convergence; stuck → auto-TODO (no confirmation).',
-  },
-  ulw: {
-    alias: 'ultrawork',
-  },
-  울트라워크: {
-    alias: 'ultrawork',
-  },
-
-  // 계획 모드
-  plan: {
-    name: 'Plan Mode',
-    description: 'Planning interview mode',
-    flags: ['planning', 'interview'],
-    output: '[PLAN MODE] Enter planning interview mode. Gather requirements before implementation.',
-    strict: true, // 일상어 — 명령 끝 위치 또는 --plan 플래그에서만 (오탐 방지)
-  },
-
-  // Ralph + Plan 조합
-  ralplan: {
-    name: 'Ralph Plan',
-    description: 'Iterative planning with persistence',
-    flags: ['persistence', 'planning', 'iteration'],
-    output: '[RALPLAN MODE] Iterative planning with consensus. Will refine plan until approved, then execute with Ralph persistence.',
-  },
-
-  // Deprecated: 기본 JUDGE는 항상 결정론 검증 (no-op)
-  verify: {
-    name: 'Verify (deprecated alias)',
-    description: '[deprecated] Deterministic verification is the default; alias mapped',
-    flags: ['verification', 'strict'],
-    output: '[vibe] \'verify\' is deprecated — deterministic JUDGE is the default; alias mapped.',
-    strict: true, // 일상어 ("please verify the fix" 오탐 방지)
-  },
-
-  // 탐색 모드
-  explore: {
-    name: 'Explore Mode',
-    description: 'Deep codebase exploration',
-    flags: ['exploration', 'thorough'],
-    output: '[EXPLORE MODE] Deep exploration enabled. Use multiple Explore agents for thorough codebase analysis.',
-    strict: true, // 일상어 ("let me explore the options" 오탐 방지)
-  },
-
-  // Deprecated: --max-iter 1 매핑
-  quick: {
-    name: 'Quick (deprecated alias)',
-    description: '[deprecated] Maps to --max-iter 1; use --max-iter 1 explicitly',
-    flags: ['fast', 'minimal_verification'],
-    output: '[vibe] \'quick\' maps to --max-iter 1 (single-pass, minimal JUDGE).',
-    strict: true, // 일상어 ("quick question on auth" 오탐 방지)
-  },
-};
-
-// 키워드 조합 시너지 (deprecated alias 조합도 매핑 유지)
-const KEYWORD_SYNERGIES = {
-  'ralph+ultrawork': {
-    name: 'Ralph+Ultrawork (deprecated)',
-    output: '[vibe] \'ralph\'+\'ultrawork\' deprecated: automationLevel: autonomous + parallel ACT, exit=coverage-100.',
-  },
-  'ralph+verify': {
-    name: 'Ralph+Verify (deprecated)',
-    output: '[vibe] \'ralph\'+\'verify\' deprecated: both are default behavior; alias mapped.',
-  },
-  'ultrawork+explore': {
-    name: 'Ultrawork+Explore',
-    output: '[ULTRAWORK+EXPLORE] automationLevel: autonomous + parallel exploration agents.',
-  },
-};
-
-/**
- * 텍스트에서 키워드 추출
- */
-function detectKeywords(text) {
-  const lowerText = text.toLowerCase();
-  const detected = [];
-  const resolvedKeywords = new Map();
-
-  for (const [keyword, config] of Object.entries(MAGIC_KEYWORDS)) {
-    // alias는 본체의 strict 설정을 따른다.
-    const target = config.alias ? MAGIC_KEYWORDS[config.alias] : config;
-    // strict 키워드(일상어: quick/plan/verify/explore)는 단어경계만으로는
-    // "quick question", "please verify" 등에 오탐한다. 따라서
-    //   ① 명령 끝 위치의 독립 토큰 ("... 만들어줘 quick")  또는
-    //   ② 명시 플래그 ("--quick", "-quick", "/quick")
-    // 에서만 매칭한다. 조어(ralph/ultrawork)는 오탐이 거의 없어 단어경계 유지.
-    const regex = target.strict
-      ? new RegExp(`(?:(?:^|\\s)--?${keyword}\\b)|(?:(?:^|\\s)${keyword}\\s*$)`, 'i')
-      : new RegExp(`\\b${keyword}\\b`, 'i');
-    if (regex.test(lowerText)) {
-      // alias 해결
-      const resolved = config.alias ? MAGIC_KEYWORDS[config.alias] : config;
-      const resolvedName = config.alias || keyword;
-
-      if (!resolvedKeywords.has(resolvedName)) {
-        resolvedKeywords.set(resolvedName, resolved);
-        detected.push({
-          keyword: resolvedName,
-          original: keyword,
-          ...resolved,
-        });
-      }
-    }
-  }
-
-  return detected;
-}
-
-/**
- * 키워드 조합 처리
- */
-function processCombinations(detected) {
-  if (detected.length <= 1) {
-    return null;
-  }
-
-  // 키워드 이름 정렬하여 조합 키 생성
-  const keywordNames = detected.map(d => d.keyword).sort();
-
-  // 모든 2-조합 확인
-  for (let i = 0; i < keywordNames.length; i++) {
-    for (let j = i + 1; j < keywordNames.length; j++) {
-      const comboKey = `${keywordNames[i]}+${keywordNames[j]}`;
-      if (KEYWORD_SYNERGIES[comboKey]) {
-        return KEYWORD_SYNERGIES[comboKey];
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * 모든 플래그 수집
- */
-function collectFlags(detected) {
-  const flags = new Set();
-  for (const d of detected) {
-    if (d.flags) {
-      d.flags.forEach(f => flags.add(f));
-    }
-  }
-  return Array.from(flags);
-}
-
-/**
- * 출력 생성
- */
-function generateOutput(detected, combination) {
-  const outputs = [];
-
-  // 시너지 조합 우선
-  if (combination) {
-    outputs.push(combination.output);
-  } else {
-    // 개별 키워드 출력
-    for (const d of detected) {
-      if (d.output) {
-        outputs.push(d.output);
-      }
-    }
-  }
-
-  // 모든 플래그 수집
-  const flags = collectFlags(detected);
-  if (flags.length > 0) {
-    outputs.push(`[FLAGS] ${flags.join(', ')}`);
-  }
-
-  return outputs.join('\n');
-}
-
-// 메인 실행
-const input = process.argv.slice(2).join(' ') || process.env.USER_PROMPT || '';
-
-if (!input) {
-  console.log(`
-VIBE Keyword Detector
-
-Available magic keywords:
-${Object.entries(MAGIC_KEYWORDS)
-  .filter(([_, v]) => !v.alias)
-  .map(([k, v]) => `  ${k.padEnd(12)} - ${v.description}`)
-  .join('\n')}
-
-Keyword combinations:
-${Object.entries(KEYWORD_SYNERGIES)
-  .map(([k, v]) => `  ${k.padEnd(20)} - ${v.name}`)
-  .join('\n')}
-
-Usage:
-  node keyword-detector.js "implement login ralph ultrawork"
-  `);
-  process.exit(0);
-}
-
-const detected = detectKeywords(input);
-
-if (detected.length > 0) {
-  const combination = processCombinations(detected);
-  const output = generateOutput(detected, combination);
-  console.log(output);
-}

package/skills/characterization-test/SKILL.md

@@ -1,209 +0,0 @@
----
-name: characterization-test
-user-invocable: false
-invocation: [auto]
-tier: core
-description: "Lock existing behavior with characterization tests BEFORE refactoring or modifying legacy/untested code (files >200 lines without tests)."
-triggers: [legacy, characterization test, lock behavior, regression prevention, before refactor, large file, refactor, rewrite, modernize, clean up]
-priority: 65
----
-
-# Characterization Test Skill
-
-> **Philosophy: "Never change what you cannot verify"**
-
-Lock existing behavior with snapshot/characterization tests before modifying code. This prevents regressions in legacy, complex, or unfamiliar codebases.
-
-## Pre-check (K1)
-
-> Are you modifying existing code with uncertain behavior? If the code is new (you just wrote it), well-tested, or trivially simple, skip characterization tests and write regular unit tests instead.
-
-## When to Use
-
-| Scenario | Signal |
-|----------|--------|
-| Legacy file (>500 lines) | Large files with accumulated behavior |
-| Complex branching | Multiple if/else, switch, ternary chains |
-| API endpoint modification | Request/response contract must be preserved |
-| Database schema change | Migration must preserve existing data semantics |
-| Refactoring request | "refactor", "clean up", "simplify" keywords |
-| Unfamiliar code | No prior context about the module |
-
-## Core Workflow
-
-```
-ANALYZE → GENERATE → VERIFY → CHANGE → REGRESS → RECONCILE
-```
-
-### Step 1: ANALYZE
-
-Explore the target code to understand its current behavior.
-
-**Parallel exploration** (use sub-agents when available):
-- Read the target file(s)
-- Identify all public exports / API surface
-- Map branching paths (if/else, switch, try/catch)
-- List external dependencies and side effects
-- Check for existing tests
-
-**Analysis checklist:**
-- [ ] All public functions identified
-- [ ] Input parameter ranges documented
-- [ ] Edge cases listed (null, empty, boundary values)
-- [ ] Side effects cataloged (DB writes, file I/O, network calls)
-- [ ] Error paths mapped
-
-### Step 2: GENERATE
-
-Create characterization tests that capture current behavior as-is.
-
-**TypeScript template:**
-```typescript
-import { describe, it, expect } from 'vitest';
-
-describe('[ModuleName] characterization tests', () => {
-  // Happy path - capture normal behavior
-  it('should [describe current behavior]', () => {
-    const result = targetFunction(normalInput);
-    // Snapshot the ACTUAL output, not what you THINK it should be
-    expect(result).toMatchSnapshot();
-  });
-
-  // Edge cases - capture boundary behavior
-  it('should handle empty input', () => {
-    const result = targetFunction('');
-    expect(result).toMatchSnapshot();
-  });
-
-  // Error paths - capture failure modes
-  it('should handle invalid input', () => {
-    expect(() => targetFunction(null)).toThrowErrorMatchingSnapshot();
-  });
-});
-```
-
-**Python template:**
-```python
-import pytest
-
-class TestModuleNameCharacterization:
-    """Lock existing behavior before modification."""
-
-    def test_normal_behavior(self, snapshot):
-        result = target_function(normal_input)
-        assert result == snapshot
-
-    def test_empty_input(self, snapshot):
-        result = target_function("")
-        assert result == snapshot
-
-    def test_invalid_input(self):
-        with pytest.raises(Exception) as exc_info:
-            target_function(None)
-        assert str(exc_info.value)  # Capture error message
-```
-
-**Key principles:**
-- Test ACTUAL behavior, not expected behavior
-- Use `toMatchSnapshot()` / snapshot assertions
-- Cover every public function
-- Include edge cases and error paths
-- Do NOT fix bugs in characterization tests
-
-### Step 3: VERIFY
-
-Run the characterization tests to confirm they pass with current code.
-
-```bash
-# TypeScript
-npx vitest run --reporter=verbose [test-file]
-
-# Python
-pytest -v [test-file]
-```
-
-- All tests MUST pass before proceeding
-- If any test fails, the characterization is wrong — fix the test, not the code
-- Update snapshots if needed: `npx vitest run -u [test-file]`
-
-### Step 4: CHANGE
-
-Now implement the requested modification.
-
-- Make changes incrementally
-- Run characterization tests after each change
-- Any unexpected test failure = potential regression
-
-### Step 5: REGRESS
-
-Run full characterization test suite after all changes.
-
-```bash
-npx vitest run [characterization-test-file]
-```
-
-- **All passing**: Changes preserve existing behavior
-- **Expected failures**: Tests for intentionally changed behavior
-- **Unexpected failures**: STOP — investigate regression
-
-### Step 6: RECONCILE
-
-Update characterization tests to match new intended behavior.
-
-- Review each failing test individually
-- Confirm the failure is due to intentional change
-- Update snapshot: `npx vitest run -u`
-- Add NEW tests for new behavior
-- Document why each test changed
-
-## Scenario-Specific Workflows
-
-### Legacy File (>500 lines)
-
-1. Generate function-level characterization tests
-2. Focus on public API surface first
-3. Add integration tests for cross-function flows
-4. Refactor in small increments
-
-### Complex Branching
-
-1. Map all branches with a decision tree
-2. Write one test per branch path
-3. Include boundary values for each condition
-4. Test combinations of related conditions
-
-### API Endpoint
-
-1. Capture request/response pairs for all routes
-2. Test all HTTP methods, status codes, headers
-3. Include authentication/authorization paths
-4. Test error responses and validation messages
-
-### Database Schema
-
-1. Create fixtures with representative data
-2. Test queries before and after migration
-3. Verify data integrity post-migration
-4. Test rollback scenarios
-
-## Integration with VIBE Workflow
-
-### With `/vibe.spec`
-Add characterization test phase to SPEC before implementation:
-```
-## Pre-Implementation
-- [ ] Characterization tests written for affected modules
-- [ ] All characterization tests passing
-```
-
-### With `/vibe.run`
-The implementation agent should:
-1. Check for characterization tests before modifying files
-2. Run them before and after changes
-3. Flag any unexpected failures
-
-### With `/vibe.review`
-Review agents verify:
-- Characterization tests exist for modified legacy code
-- No regressions in existing behavior
-- New behavior has corresponding new tests

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