@su-record/vibe 2.16.4 → 3.1.0

package/hooks/scripts/__tests__/keyword-detector.test.js

@@ -1,242 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { execFileSync } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SCRIPT = path.resolve(__dirname, '..', 'keyword-detector.js');
-
-/**
- * Run keyword-detector.js with given text as argv.
- * Returns { stdout, exitCode }.
- */
-function runDetector(text) {
-  try {
-    const stdout = execFileSync('node', [SCRIPT, text], {
-      encoding: 'utf-8',
-      timeout: 5000,
-    });
-    return { stdout: stdout.trim(), exitCode: 0 };
-  } catch (err) {
-    return { stdout: (err.stdout || '').trim(), exitCode: err.status };
-  }
-}
-
-// ══════════════════════════════════════════════════
-// Individual keyword detection
-// ══════════════════════════════════════════════════
-describe('keyword-detector', () => {
-  describe('ralph keyword', () => {
-    it('should detect ralph keyword and emit deprecation hint', () => {
-      const result = runDetector('implement the login feature ralph');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('deprecated');
-      expect(result.stdout).toContain('persistence');
-    });
-
-    it('should detect ralph case-insensitively', () => {
-      const result = runDetector('RALPH fix all the bugs');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('deprecated');
-    });
-  });
-
-  describe('ultrawork keyword', () => {
-    it('should detect ultrawork keyword and emit automationLevel banner', () => {
-      const result = runDetector('ultrawork build the entire app');
-      expect(result.stdout).toContain('[ULTRAWORK]');
-      expect(result.stdout).toContain('parallel');
-    });
-
-    it('should detect ulw alias', () => {
-      const result = runDetector('ulw refactor the codebase');
-      expect(result.stdout).toContain('[ULTRAWORK]');
-    });
-
-    it('should detect Korean alias when word boundary matches', () => {
-      // Note: \\b word boundary may not match Korean characters reliably
-      // because \\b is designed for ASCII word boundaries.
-      // This test documents the current behavior.
-      const result = runDetector('울트라워크');
-      // Korean chars lack ASCII word boundaries, so regex may not match
-      // If it does match, great; if not, this documents the limitation
-      expect(typeof result.stdout).toBe('string');
-    });
-  });
-
-  describe('ralplan keyword', () => {
-    it('should detect ralplan keyword', () => {
-      const result = runDetector('ralplan design the architecture');
-      expect(result.stdout).toContain('[RALPLAN MODE]');
-      expect(result.stdout).toContain('persistence');
-      expect(result.stdout).toContain('planning');
-    });
-  });
-
-  // strict 키워드(일상어): 명령 끝 위치 또는 --flag 에서만 발동.
-  // 일상 영어("please verify", "quick question")의 오탐을 막기 위함.
-  describe('verify keyword (strict)', () => {
-    it('should detect verify at command tail and emit deprecation hint', () => {
-      const result = runDetector('make the implementation correct, verify');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('deprecated');
-      expect(result.stdout).toContain('verification');
-    });
-
-    it('should detect --verify flag', () => {
-      const result = runDetector('fix the bug --verify');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('deprecated');
-    });
-  });
-
-  describe('quick keyword (strict)', () => {
-    it('should detect quick at command tail and emit --max-iter 1 hint', () => {
-      const result = runDetector('fix this typo quick');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('--max-iter 1');
-      expect(result.stdout).toContain('fast');
-    });
-
-    it('should detect --quick flag', () => {
-      const result = runDetector('build the payment API --quick');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('--max-iter 1');
-    });
-  });
-
-  describe('explore keyword (strict)', () => {
-    it('should detect --explore flag', () => {
-      const result = runDetector('analyze the codebase --explore');
-      expect(result.stdout).toContain('[EXPLORE MODE]');
-      expect(result.stdout).toContain('exploration');
-    });
-  });
-
-  describe('plan keyword (strict)', () => {
-    it('should detect --plan flag', () => {
-      const result = runDetector('the new feature --plan');
-      expect(result.stdout).toContain('[PLAN MODE]');
-      expect(result.stdout).toContain('planning');
-    });
-  });
-
-  // ══════════════════════════════════════════════════
-  // 오탐 방지 회귀 테스트 — 일상어가 명령 중간/시작에 올 때 발동 금지
-  // ══════════════════════════════════════════════════
-  describe('strict keyword false-positive guard', () => {
-    it('should NOT trigger on "quick question on auth"', () => {
-      expect(runDetector('quick question on auth').stdout).toBe('');
-    });
-
-    it('should NOT trigger on "please verify the fix works"', () => {
-      expect(runDetector('please verify the fix works').stdout).toBe('');
-    });
-
-    it('should NOT trigger on "I plan to refactor later"', () => {
-      expect(runDetector('I plan to refactor later').stdout).toBe('');
-    });
-
-    it('should NOT trigger on "let me explore the options first"', () => {
-      expect(runDetector('let me explore the options first').stdout).toBe('');
-    });
-  });
-
-  // ══════════════════════════════════════════════════
-  // Keyword combinations / synergies
-  // ══════════════════════════════════════════════════
-  describe('keyword combinations', () => {
-    it('should detect ralph+ultrawork synergy and emit deprecation hint', () => {
-      const result = runDetector('ralph ultrawork build everything from scratch');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('deprecated');
-      expect(result.stdout).toContain('persistence');
-      expect(result.stdout).toContain('parallel');
-    });
-
-    it('should detect ralph+verify synergy and emit deprecation hint', () => {
-      // verify is strict → use --verify flag (ralph stays bare)
-      const result = runDetector('ralph fix each step --verify');
-      expect(result.stdout).toContain('[vibe]');
-      expect(result.stdout).toContain('deprecated');
-    });
-
-    it('should output both keywords when no synergy key matches sorted order', () => {
-      // KEYWORD_SYNERGIES defines 'ultrawork+explore' but processCombinations
-      // sorts keywords alphabetically → tries 'explore+ultrawork' which has no match.
-      // So individual outputs are emitted instead. explore is strict → --explore.
-      const result = runDetector('ultrawork analyze the entire project --explore');
-      expect(result.stdout).toContain('[ULTRAWORK]');
-      expect(result.stdout).toContain('[EXPLORE MODE]');
-      expect(result.stdout).toContain('[FLAGS]');
-    });
-  });
-
-  // ══════════════════════════════════════════════════
-  // No keywords
-  // ══════════════════════════════════════════════════
-  describe('no keywords detected', () => {
-    it('should output nothing when no keywords present', () => {
-      const result = runDetector('just a normal prompt with no magic words');
-      expect(result.stdout).toBe('');
-    });
-
-    it('should not match partial words', () => {
-      // "verify" inside "verifying" — depends on word boundary regex
-      // The regex uses \b so "verifying" would NOT match "verify" as a whole word
-      // Actually \bverify\b would match "verify" in "verifying"? No — "verifying" has
-      // chars after "verify" that are word chars, so \bverify\b won't match.
-      const result = runDetector('verifying the output looks good');
-      expect(result.stdout).toBe('');
-    });
-
-    it('should not match keywords embedded in other words', () => {
-      const result = runDetector('exploration of quickly planning');
-      // "explore" should NOT match "exploration" (word boundary)
-      // "quick" should NOT match "quickly"
-      // "plan" should NOT match "planning"
-      expect(result.stdout).toBe('');
-    });
-  });
-
-  // ══════════════════════════════════════════════════
-  // Empty input — shows help
-  // ══════════════════════════════════════════════════
-  describe('help output', () => {
-    it('should show usage info with no input', () => {
-      const result = runDetector('');
-      // Empty string arg is still truthy, pass no args instead
-      try {
-        const stdout = execFileSync('node', [SCRIPT], {
-          encoding: 'utf-8',
-          timeout: 5000,
-        });
-        expect(stdout).toContain('Available magic keywords');
-        expect(stdout).toContain('Keyword combinations');
-      } catch (err) {
-        // Should exit 0, but just in case
-        expect(err.stdout || '').toContain('Available magic keywords');
-      }
-    });
-  });
-
-  // ══════════════════════════════════════════════════
-  // Flags collection
-  // ══════════════════════════════════════════════════
-  describe('flags output', () => {
-    it('should output collected flags for single keyword', () => {
-      const result = runDetector('ralph do the thing');
-      expect(result.stdout).toContain('[FLAGS]');
-      expect(result.stdout).toContain('persistence');
-      expect(result.stdout).toContain('verification');
-    });
-
-    it('should merge flags from multiple keywords', () => {
-      // quick is strict → place at command tail; ralph stays bare
-      const result = runDetector('ralph finish this quick');
-      expect(result.stdout).toContain('[FLAGS]');
-      expect(result.stdout).toContain('persistence');
-      expect(result.stdout).toContain('fast');
-    });
-  });
-});

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