@su-record/vibe 2.7.11 → 2.7.12

package/skills/arch-guard/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: arch-guard
+description: "Generate architecture boundary tests that mechanically enforce layer constraints."
+triggers: [arch guard, architecture test, layer test, boundary test, structural test, arch validation]
+priority: 60
+---
+
+# Arch Guard — Architecture Boundary Test Generator
+
+> **Principle**: "Mechanical enforcement over documentation." If a rule exists only in docs, it will be violated. Turn architecture constraints into failing tests.
+
+## When to Use
+
+| Scenario | Signal |
+|----------|--------|
+| `vibe init` / `vibe update` | Auto-generate for detected stack |
+| New layer/module added | Boundaries need enforcement |
+| Architecture violation found in review | Prevent recurrence with test |
+| "Services should not import UI" type rules | Turn into automated check |
+
+## Core Flow
+
+```
+DETECT → INFER → GENERATE → VERIFY
+```
+
+### Step 1: DETECT — Identify Project Architecture
+
+Analyze the project to determine its layer structure:
+
+```
+Parallel exploration:
+- Agent 1: Scan directory structure (src/, app/, lib/, etc.)
+- Agent 2: Read existing architecture docs (CLAUDE.md, README, ADR)
+- Agent 3: Analyze import graph (which files import what)
+```
+
+**Common patterns to detect:**
+
+| Pattern | Layers | Typical Stacks |
+|---------|--------|----------------|
+| MVC | Controller → Service → Model | Rails, NestJS, Spring |
+| Clean Architecture | UI → Application → Domain → Infrastructure | General |
+| Feature-based | Feature A ↛ Feature B internals | Next.js, React |
+| Hexagonal | Adapters → Ports → Domain | DDD projects |
+| Component hierarchy | Page → Feature → Shared → UI Primitives | Frontend |
+
+### Step 2: INFER — Define Boundary Rules
+
+From detected structure, generate rules:
+
+```typescript
+// Rule format
+interface ArchRule {
+  name: string;           // "service-no-ui-import"
+  from: string;           // Glob pattern: "src/services/**"
+  cannotImport: string[]; // ["src/components/**", "src/pages/**"]
+  canImport: string[];    // ["src/models/**", "src/utils/**"]
+  reason: string;         // "Services must be UI-agnostic"
+}
+```
+
+**Default rules by stack:**
+
+| Stack | Rule |
+|-------|------|
+| Next.js / React | `components/` cannot import from `pages/` or `app/` |
+| Next.js / React | `lib/` cannot import from `components/` |
+| NestJS | `*.service.ts` cannot import from `*.controller.ts` |
+| NestJS | `*.module.ts` is the only valid cross-boundary import |
+| General TS | `src/domain/` cannot import from `src/infra/` |
+| General TS | No circular dependencies between top-level dirs |
+| Python Django | `models.py` cannot import from `views.py` |
+| Python FastAPI | `schemas/` cannot import from `routers/` |
+
+### Step 3: GENERATE — Create Test File
+
+Output: `tests/arch-guard.test.ts` (or equivalent for stack)
+
+```typescript
+/**
+ * Architecture Boundary Tests
+ * Generated by arch-guard skill
+ *
+ * These tests enforce architectural constraints mechanically.
+ * If a test fails, it means an import violates the intended architecture.
+ */
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+// Helper: extract imports from a file
+function extractImports(filePath: string): string[] {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const importRegex = /(?:import|require)\s*\(?['"]([^'"]+)['"]\)?/g;
+  const imports: string[] = [];
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+  return imports;
+}
+
+// Helper: resolve relative import to absolute path
+function resolveImport(fromFile: string, importPath: string): string {
+  if (importPath.startsWith('.')) {
+    return path.resolve(path.dirname(fromFile), importPath);
+  }
+  return importPath; // external package
+}
+
+// Helper: glob files matching pattern
+function globFiles(pattern: string, baseDir: string): string[] {
+  // Use fast-glob or manual recursive scan
+  // Implementation depends on available dependencies
+}
+
+describe('Architecture Boundaries', () => {
+  // GENERATED RULES GO HERE
+  // Each rule becomes a test case:
+
+  it('services cannot import UI components', () => {
+    const serviceFiles = globFiles('src/services/**/*.ts', process.cwd());
+    const violations: string[] = [];
+
+    for (const file of serviceFiles) {
+      const imports = extractImports(file);
+      for (const imp of imports) {
+        const resolved = resolveImport(file, imp);
+        if (resolved.includes('/components/') || resolved.includes('/pages/')) {
+          violations.push(`${file} imports ${imp}`);
+        }
+      }
+    }
+
+    expect(violations).toEqual([]);
+  });
+});
+```
+
+### Step 4: VERIFY — Run and Fix
+
+1. Run the generated tests: `npx vitest run tests/arch-guard.test.ts`
+2. If violations found:
+   - Report each violation with file:line
+   - Suggest fix (move shared code to appropriate layer)
+   - Do NOT auto-fix — violations need human review
+
+## Output Files
+
+| File | Purpose |
+|------|---------|
+| `tests/arch-guard.test.ts` | Executable boundary tests |
+| `.claude/vibe/arch-rules.json` | Machine-readable rules (for CI) |
+
+## Customization
+
+Users can add custom rules to `.claude/vibe/arch-rules.json`:
+
+```json
+{
+  "rules": [
+    {
+      "name": "no-direct-db-in-handlers",
+      "from": "src/handlers/**",
+      "cannotImport": ["src/db/**"],
+      "reason": "Handlers must use services, not direct DB access"
+    }
+  ]
+}
+```
+
+The test generator reads this file and adds custom rules to the test suite.
+
+## Integration
+
+- `vibe init` → auto-detect and generate initial arch-guard tests
+- `vibe update` → refresh rules if directory structure changed
+- Pre-commit hook → run arch-guard tests before commit
+- `/vibe.review` → architecture-reviewer checks against arch-rules.json

package/skills/capability-loop/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: capability-loop
+description: "When an agent fails, diagnose which capability is missing and build it into the repo."
+triggers: [capability loop, failure loop, build capability, missing capability, agent failed, why did it fail]
+priority: 75
+---
+
+# Capability Loop — Failure → Capability Building
+
+> **Principle**: "Ask what capability is missing, not why it failed." Every failure is a missing tool, guardrail, abstraction, or piece of documentation. Build the capability so the failure NEVER recurs.
+
+## When to Use
+
+| Trigger | Signal |
+|---------|--------|
+| Agent fails a task | Error, wrong output, timeout, confusion |
+| Same error occurs twice | Pattern of missing capability |
+| Agent asks clarifying question | Information not discoverable |
+| Review finds recurring issue | Systemic gap, not one-off mistake |
+| Manual intervention needed | Agent should have been self-sufficient |
+
+## Core Flow
+
+```
+FAILURE → DIAGNOSE → CLASSIFY → BUILD → VERIFY → PERSIST
+```
+
+### Step 1: DIAGNOSE — What Capability is Missing?
+
+Do NOT ask "why did it fail?" Instead ask: **"What would have prevented this failure?"**
+
+```
+Diagnosis questions (answer ALL):
+
+1. TOOL: Did the agent lack a tool to accomplish the task?
+   → Missing CLI command, missing API, missing utility function
+
+2. GUARDRAIL: Did the agent do something it shouldn't have?
+   → Missing lint rule, missing test, missing hook check
+
+3. ABSTRACTION: Did the agent struggle with unnecessary complexity?
+   → Missing helper, missing wrapper, missing shared module
+
+4. DOCUMENTATION: Did the agent lack discoverable information?
+   → Missing CLAUDE.md entry, missing code comment, missing type definition
+
+5. FEEDBACK: Did the agent not know it was doing the wrong thing?
+   → Missing error message, missing test assertion, missing type error
+```
+
+### Step 2: CLASSIFY — What Type of Capability?
+
+| Category | Example | Where to Build |
+|----------|---------|---------------|
+| **Tool** | "No way to validate schema" | New CLI command or skill |
+| **Guardrail** | "Accidentally deleted migration" | New hook or test |
+| **Abstraction** | "Copy-pasted auth logic 3 times" | New shared module |
+| **Documentation** | "Didn't know config format" | CLAUDE.md or code comments |
+| **Feedback** | "Didn't realize test was wrong" | Better error messages or types |
+
+### Step 3: BUILD — Create the Capability
+
+Based on classification, build the appropriate artifact:
+
+#### Tool → New Skill or Command
+```
+1. Create skills/{capability-name}/SKILL.md
+2. Add triggers for automatic activation
+3. Test with a simulated scenario
+```
+
+#### Guardrail → New Test or Hook
+```
+1. Add test to tests/arch-guard.test.ts (if structural)
+2. Or add check to hooks/scripts/ (if runtime)
+3. Verify it catches the original failure
+```
+
+#### Abstraction → New Module
+```
+1. Extract shared code into appropriate location
+2. Update existing callers to use new abstraction
+3. Add tests for the abstraction
+```
+
+#### Documentation → CLAUDE.md or Inline
+```
+1. If it's a constraint/gotcha → add to CLAUDE.md "Gotchas" section
+2. If it's discoverable from code → add code comment or type definition
+3. If it's a pattern → add to relevant language rule file
+```
+
+#### Feedback → Better Types or Errors
+```
+1. Add TypeScript type that prevents the mistake at compile time
+2. Or add runtime validation with clear error message
+3. Or add test that catches the mistake early
+```
+
+### Step 4: VERIFY — Reproduce and Confirm Fix
+
+```
+1. Reproduce the original failure scenario
+2. Confirm the new capability prevents it
+3. Run existing tests to verify no regressions
+4. If the capability is a test, verify it FAILS without the fix
+```
+
+### Step 5: PERSIST — Record for Future Reference
+
+Save the capability-building decision:
+
+```
+save_memory("capability-{name}", {
+  failure: "description of what failed",
+  diagnosis: "what capability was missing",
+  category: "tool|guardrail|abstraction|documentation|feedback",
+  solution: "what was built",
+  files_changed: ["list of files"]
+})
+```
+
+Update `.claude/vibe/capabilities-log.md`:
+
+```markdown
+## {date} — {capability-name}
+
+**Failure**: {what happened}
+**Missing**: {what capability was absent}
+**Built**: {what was created}
+**Files**: {list}
+**Prevents**: {what class of failures this prevents}
+```
+
+## Decision Tree
+
+```
+Agent failed
+    │
+    ├─ Could a TOOL have done it automatically?
+    │   YES → Build tool (skill/command/script)
+    │
+    ├─ Should the agent have been PREVENTED from doing it?
+    │   YES → Build guardrail (hook/test/lint rule)
+    │
+    ├─ Was the agent REPEATING work that should be shared?
+    │   YES → Build abstraction (module/helper/utility)
+    │
+    ├─ Did the agent lack KNOWLEDGE it needed?
+    │   YES → Add documentation (CLAUDE.md/comments/types)
+    │
+    └─ Did the agent not KNOW it was wrong?
+        YES → Build feedback (types/errors/tests)
+```
+
+## Anti-patterns
+
+- "Add a note to be more careful" → Build a guardrail instead
+- "Document the right way to do it" → If possible, make the wrong way a compile/test error
+- "Tell the agent to check X first" → Make X discoverable automatically
+- "It was a one-off mistake" → If it happened once, it will happen again. Build the capability.
+
+## Integration Points
+
+- After `/vibe.run` failure → auto-trigger capability-loop diagnosis
+- After `/vibe.review` findings → suggest capability-loop for recurring patterns
+- After manual agent correction → prompt "What capability would have prevented this?"

package/skills/exec-plan/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: exec-plan
+description: "Convert SPEC into a self-contained execution plan that agents can run autonomously for hours."
+triggers: [exec plan, execution plan, autonomous plan, self-contained plan, long-running]
+priority: 70
+---
+
+# ExecPlan — Self-Contained Execution Plan Generator
+
+> **Principle**: "If the agent can't see it, it doesn't exist." Every decision, file path, pattern, and verification step must be explicit in the plan — no implicit knowledge allowed.
+
+## When to Use
+
+Before `/vibe.run`, generate an ExecPlan to make execution deterministic:
+
+| Scenario | Signal |
+|----------|--------|
+| Complex SPEC (3+ phases) | Agent needs long autonomous execution |
+| Team/multi-agent execution | Multiple agents need shared understanding |
+| Context window pressure | Plan survives `/new` session handoff |
+| Unfamiliar codebase | Agent can't rely on implicit knowledge |
+
+## Core Flow
+
+```
+SPEC + Feature → ANALYZE → RESOLVE → GENERATE → PERSIST
+```
+
+### Step 1: ANALYZE — Extract Everything Needed
+
+Read the SPEC and Feature files, then extract:
+
+```
+For each Phase → For each Scenario:
+  1. Requirements (REQ-* IDs)
+  2. Given/When/Then conditions
+  3. Affected files (MUST exist — verify with Glob)
+  4. Dependencies (imports, packages)
+  5. Existing patterns to follow (read actual code, don't assume)
+```
+
+**Parallel exploration** (3+ agents):
+- Agent 1: Map all file paths mentioned/implied in SPEC → verify they exist
+- Agent 2: For each affected file, extract current interfaces/types/exports
+- Agent 3: Find existing patterns (naming conventions, error handling, test structure)
+
+### Step 2: RESOLVE — Eliminate All Ambiguity
+
+For every decision point in the SPEC, resolve it NOW:
+
+| Ambiguity | Resolution |
+|-----------|------------|
+| "Add validation" | → Which fields? What rules? What error messages? |
+| "Handle errors" | → Which error codes? What response format? |
+| "Follow existing pattern" | → Copy the ACTUAL pattern code into the plan |
+| "Update tests" | → Which test file? What test framework? What assertions? |
+
+**Rule**: If you'd need to "figure it out later", resolve it now. The plan must be executable by an agent with ZERO codebase knowledge.
+
+### Step 3: GENERATE — Write the ExecPlan
+
+Output format: `.claude/vibe/specs/{feature-name}-execplan.md`
+
+```markdown
+# ExecPlan: {feature-name}
+
+## Meta
+- SPEC: .claude/vibe/specs/{name}.md
+- Feature: .claude/vibe/features/{name}.feature
+- Generated: {timestamp}
+- Phases: {count}
+- Scenarios: {count}
+
+## Pre-flight Checks
+- [ ] `npm run build` passes
+- [ ] `npx vitest run` passes (baseline)
+- [ ] Required files exist: {list}
+
+## Phase {N}: {phase-name}
+
+### Environment
+- Files to modify: {exact paths}
+- Files to create: {exact paths}
+- Dependencies to add: {package@version}
+- Patterns to follow: (inline code snippets from codebase)
+
+### Scenario {N}.{M}: {scenario-name}
+
+**Given**: {precondition}
+→ Setup: {exact code/commands to establish precondition}
+
+**When**: {action}
+→ Implement: {step-by-step implementation instructions}
+  - File: {path}
+  - Location: after line containing `{anchor text}`
+  - Code: (inline snippet)
+  - Imports needed: {list}
+
+**Then**: {expected result}
+→ Verify:
+  - Command: `{test command}`
+  - Expected: {output/behavior}
+  - Fallback: {what to do if verification fails}
+
+### Phase {N} Gate
+- [ ] Build: `npm run build`
+- [ ] Tests: `npx vitest run {relevant-test-files}`
+- [ ] Type check: `npx tsc --noEmit`
+
+## Completion Criteria
+- Coverage threshold: ≥95%
+- All scenarios passing
+- No regressions in existing tests
+- RTM: `generateTraceabilityMatrix("{feature-name}")`
+```
+
+### Step 4: PERSIST — Save and Link
+
+1. Save ExecPlan to `.claude/vibe/specs/{feature-name}-execplan.md`
+2. Save session context: `save_memory("execplan-{feature}", {summary})`
+3. Output execution command:
+
+```
+Ready to execute:
+  /vibe.run "{feature-name}" ultrawork
+
+Or hand off to new session:
+  /vibe.utils --continue
+  → Load: .claude/vibe/specs/{feature-name}-execplan.md
+```
+
+## Quality Checks
+
+| Check | Criteria |
+|-------|----------|
+| No implicit knowledge | Every file path verified with Glob |
+| No "figure it out" | Every decision resolved with actual code |
+| Survives handoff | Plan readable without any prior context |
+| Inline patterns | Actual code snippets, not "follow existing pattern" |
+| Verification steps | Every scenario has a concrete verification command |
+
+## Anti-patterns
+
+- "See the existing implementation" → Copy the relevant code inline
+- "Follow the pattern in X" → Show the actual pattern
+- "Standard error handling" → Specify exact error codes and messages
+- "Update tests accordingly" → Name the test file, framework, and assertions

package/dist/agent/AgentLoop.d.ts

@@ -1,97 +0,0 @@
-/**
- * AgentLoop - 메인 에이전트 루프
- * Phase 2: Agent Core Loop
- *
- * 파이프라인:
- * message → system prompt + tools → HeadModel.chat()
- * → [tool_call → execute → result]* → final response → Telegram
- *
- * 기능:
- * - Max iterations: 10 (무한 루프 방지)
- * - Idempotency: tool_call.id 기반 중복 실행 방지
- * - HeadModel 호출 timeout: 10초, 1회 재시도
- * - 잘못된 tool_call: 에러 피드백 → 최대 2회 재시도 후 에러
- * - Circuit breaker 연동 (HeadModelSelector)
- */
-import type { ExternalMessage } from '../interface/types.js';
-import type { RouteServices } from '../router/types.js';
-import type { AgentProgressEvent, ToolDefinition } from './types.js';
-import type { HeadModelSelector } from './HeadModelSelector.js';
-import type { PolicyEngine } from '../infra/policy/PolicyEngine.js';
-import type { RateLimiter } from './RateLimiter.js';
-import type { ConversationStore } from './ConversationStore.js';
-import { ConversationState } from './ConversationState.js';
-import { type AgentLogger } from './ToolExecutor.js';
-import { type SystemPromptConfig } from './SystemPrompt.js';
-import { MediaPreprocessor, type MediaPreprocessorConfig } from './preprocessors/MediaPreprocessor.js';
-export type OnProgressCallback = (event: AgentProgressEvent) => void;
-/** Callback to drain pending instructions from SessionPool (Phase 4) */
-export type PendingInstructionsProvider = () => string | null;
-/** Callback to drain pending messages for mid-task injection (sonolbot-v2 Phase 2) */
-export type DrainPendingFn = () => ExternalMessage[];
-/** Phase 5: Conversation history callbacks */
-export type ConversationHistoryGetter = (chatId: string) => Array<{
-    role: string;
-    content: string;
-    timestamp: string;
-}>;
-export type ConversationEntrySaver = (chatId: string, role: 'user' | 'assistant', content: string) => void;
-export interface AgentLoopDeps {
-    headSelector: HeadModelSelector;
-    tools: ToolDefinition[];
-    systemPromptConfig?: SystemPromptConfig;
-    mediaPreprocessorConfig?: MediaPreprocessorConfig;
-    onProgress?: OnProgressCallback;
-    policyEngine?: PolicyEngine;
-    rateLimiter?: RateLimiter;
-    conversationStore?: ConversationStore;
-}
-/** Phase 7: Response style configuration */
-export interface ResponseStyleConfig {
-    format: 'text' | 'markdown' | 'html';
-    useEmoji: boolean;
-    tone: 'conversational' | 'formal';
-    allowMarkdownForCode: boolean;
-}
-export declare class AgentLoop {
-    private headSelector;
-    private tools;
-    private conversationState;
-    private conversationStore;
-    private toolExecutor;
-    private executedToolCalls;
-    private systemPromptConfig;
-    private mediaPreprocessor;
-    private onProgress;
-    private policyEngine;
-    private rateLimiter;
-    private pendingInstructionsProvider;
-    private conversationHistoryGetter;
-    private conversationEntrySaver;
-    private responseStyle;
-    constructor(deps: AgentLoopDeps);
-    setOnProgress(callback: OnProgressCallback | undefined): void;
-    /** Phase 7: Set response style config */
-    setResponseStyle(style: Partial<ResponseStyleConfig>): void;
-    setLogger(logger: AgentLogger): void;
-    /** Set provider for mid-task instruction injection (Phase 4) */
-    setPendingInstructionsProvider(provider: PendingInstructionsProvider): void;
-    /** Set conversation history callbacks (Phase 5) */
-    setConversationHistoryCallbacks(getter: ConversationHistoryGetter, saver: ConversationEntrySaver): void;
-    /** Get MediaPreprocessor for external use (Phase 2: pending message preprocessing) */
-    getMediaPreprocessor(): MediaPreprocessor;
-    process(message: ExternalMessage, services: RouteServices, drainPendingFn?: DrainPendingFn): Promise<void>;
-    private bindChannelTool;
-    private unbindChannelTool;
-    getConversationState(): ConversationState;
-    /**
-     * Get conversation backend (store or state)
-     * If conversationStore is provided, use it; otherwise use in-memory conversationState
-     */
-    private getConvBackend;
-    private runLoop;
-    private executeToolCalls;
-    private emitProgress;
-    private callHeadModelWithRetry;
-}
-//# sourceMappingURL=AgentLoop.d.ts.map

package/dist/agent/AgentLoop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AgentLoop.d.ts","sourceRoot":"","sources":["../../src/agent/AgentLoop.ts"],"names":[],"mappings":"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"}