vibelign 2.2.17__py3-none-win_amd64.whl

vibelign/__init__.py

@@ -0,0 +1,3 @@
+# === ANCHOR: __INIT___START ===
+__version__ = "2.2.17"
+# === ANCHOR: __INIT___END ===

vibelign/__main__.py

@@ -0,0 +1,6 @@
+# === ANCHOR: __MAIN___START ===
+from vibelign.cli import main
+
+if __name__ == "__main__":
+    main()
+# === ANCHOR: __MAIN___END ===

vibelign/_bundled/vibelign-engine.exe.sha256

@@ -0,0 +1 @@
+d5e0635fd0e9525f73f59cc817e89ad7d0666a1252b023e1ddef1831f2e93493  vibelign-engine.exe

vibelign/_vib_entry.py

@@ -0,0 +1,7 @@
+# === ANCHOR: _VIB_ENTRY_START ===
+from vibelign.cli.vib_cli import main
+
+
+if __name__ == "__main__":
+    main()
+# === ANCHOR: _VIB_ENTRY_END ===

vibelign/action_engine/__init__.py

@@ -0,0 +1,3 @@
+# === ANCHOR: ACTION_ENGINE_INIT_START ===
+"""VibeLign Action Engine — Analyze → Plan → Generate → Execute"""
+# === ANCHOR: ACTION_ENGINE_INIT_END ===

vibelign/action_engine/action_planner.py

@@ -0,0 +1,147 @@
+# === ANCHOR: ACTION_PLANNER_START ===
+"""Action Planner — DoctorV2Report를 실행 가능한 Plan으로 변환한다.
+
+흐름:
+    1. issue 목록 수집
+    2. 각 issue → 후보 Action 생성
+    3. 의존 순서 정렬 (add_anchor → split_file)
+    4. 순서 확정된 Plan 반환
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+
+from vibelign.action_engine.models.action import Action
+from vibelign.action_engine.models.plan import Plan
+
+
+# action_type 실행 우선순위 (낮을수록 먼저)
+_ACTION_PRIORITY: Dict[str, int] = {
+    "fix_project_map": 0,
+    "fix_mcp": 1,
+    "add_anchor": 2,
+    "split_file": 3,  # add_anchor 이후에만 안전
+    "review": 9,
+}
+
+# action_type → 선행 필요 action_type 목록
+_ACTION_DEPENDENCY: Dict[str, List[str]] = {
+    "split_file": ["add_anchor"],
+}
+
+
+def _classify_issue(issue: Dict[str, Any]) -> str:
+    """issue dict에서 action_type을 결정한다."""
+    category = str(issue.get("category", "")).lower()
+    found: str = issue.get("found", "")
+    next_step: str = issue.get("next_step", "")
+    recommended_command: str = str(issue.get("recommended_command", ""))
+    text = found + " " + next_step
+
+    if category == "anchor":
+        return "add_anchor"
+    if category == "mcp":
+        return "fix_mcp"
+    check_type = str(issue.get("check_type", "")).lower()
+    path = str(issue.get("path", "")).lower()
+    if (
+        check_type in {"unsupported_project_map_schema", "invalid_project_map"}
+        or "project_map" in text.lower()
+        or path.endswith(".vibelign/project_map.json")
+    ):
+        return "fix_project_map"
+    if "앵커" in text or "anchor" in text.lower():
+        return "add_anchor"
+    if "mcp.json" in text.lower():
+        return "fix_mcp"
+    if "분리" in text or "나눠" in text or "split" in text.lower():
+        return "split_file"
+    return "review"
+
+
+def _issue_to_action(issue: Dict[str, Any]) -> Action:
+    """issue dict → Action 변환. path가 None이어도 안전하게 처리."""
+    action_type = _classify_issue(issue)
+    target_path = issue.get("path")  # Optional[str] — None 가능
+
+    # 실행 명령어 결정
+    command: str | None = None
+    recommended_command = issue.get("recommended_command")
+    if isinstance(recommended_command, str) and recommended_command.strip():
+        command = recommended_command.strip()
+    else:
+        next_step: str = issue.get("next_step", "")
+        if "`" in next_step:
+            start = next_step.find("`") + 1
+            end = next_step.find("`", start)
+            if end > start:
+                command = next_step[start:end]
+        elif next_step.startswith("vib "):
+            command = next_step.strip()
+
+    depends_on = _ACTION_DEPENDENCY.get(action_type, [])
+
+    return Action(
+        action_type=action_type,
+        description=issue.get("found", ""),
+        target_path=target_path,
+        command=command,
+        depends_on=depends_on,
+    )
+
+
+def _topological_sort(actions: List[Action]) -> tuple[List[Action], List[str]]:
+    """의존 순서를 보장하는 정렬.
+
+    Returns:
+        (sorted_actions, warnings)
+    """
+    warnings: List[str] = []
+    present_types = {a.action_type for a in actions}
+
+    for action in actions:
+        for dep in action.depends_on:
+            if dep not in present_types:
+                dep_action = Action(
+                    action_type=dep,
+                    description=f"'{action.action_type}' 실행을 위해 자동 추가",
+                    target_path=action.target_path,
+                    command="vib anchor --suggest" if dep == "add_anchor" else None,
+                    depends_on=[],
+                )
+                actions.append(dep_action)
+                present_types.add(dep)
+                warnings.append(
+                    f"'{action.action_type}'이 '{dep}'에 의존해서 자동으로 추가했어요."
+                )
+
+    sorted_actions = sorted(
+        actions,
+        key=lambda a: _ACTION_PRIORITY.get(a.action_type, 9),
+    )
+    return sorted_actions, warnings
+
+
+def generate_plan(doctor_report: Any) -> Plan:
+    """DoctorV2Report 또는 그 dict로부터 Plan을 생성한다."""
+    if hasattr(doctor_report, "issues"):
+        issues: List[Dict[str, Any]] = doctor_report.issues
+        source_score: int = doctor_report.project_score
+    else:
+        issues = doctor_report.get("issues", [])
+        source_score = doctor_report.get("project_score", 0)
+
+    actions = [_issue_to_action(issue) for issue in issues]
+    sorted_actions, warnings = _topological_sort(actions)
+
+    return Plan(
+        actions=sorted_actions,
+        source_score=source_score,
+        generated_at=datetime.now(timezone.utc).isoformat(),
+        warnings=warnings,
+    )
+
+
+# === ANCHOR: ACTION_PLANNER_END ===

vibelign/action_engine/executors/__init__.py

@@ -0,0 +1,3 @@
+# === ANCHOR: ACTION_ENGINE_EXECUTORS_INIT_START ===
+"""Action Engine executors — 실제 파일 저장 레이어."""
+# === ANCHOR: ACTION_ENGINE_EXECUTORS_INIT_END ===

vibelign/action_engine/executors/action_executor.py

@@ -0,0 +1,191 @@
+# === ANCHOR: ACTION_EXECUTOR_START ===
+"""Action Executor — Plan의 Action을 실제로 실행한다.
+
+원칙:
+  - add_anchor: 자동 실행 (anchor_tools 사용)
+  - fix_mcp / fix_project_map: 명령어 안내만 (자동 실행 안전하지 않음)
+  - split_file / review: 건너뜀 (수동 작업 필요)
+  - checkpoint는 사용자가 직접 관리 (자동 생성 안 함)
+  - 파일 변경 감지 시 경고 출력
+"""
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+from vibelign.action_engine.models.action import Action
+from vibelign.action_engine.models.plan import Plan
+
+
+@dataclass
+class ExecutionResult:
+    action: Action
+    status: str        # "done" | "skipped" | "manual" | "failed"
+    detail: str = ""
+
+
+@dataclass
+class ApplyResult:
+    checkpoint_id: Optional[str]
+    results: List[ExecutionResult] = field(default_factory=list)
+    aborted: bool = False
+    needs_ai_aliases: bool = False
+
+    @property
+    def done_count(self) -> int:
+        return sum(1 for r in self.results if r.status == "done")
+
+    @property
+    def manual_count(self) -> int:
+        return sum(1 for r in self.results if r.status == "manual")
+
+
+def _check_plan_staleness(plan: Plan, root: Path) -> bool:
+    """plan 생성 후 파일이 변경됐으면 True 반환."""
+    from vibelign.core.analysis_cache import _project_mtime_hash
+    from vibelign.core.meta_paths import MetaPaths
+    import json
+
+    meta = MetaPaths(root)
+    cache_path = meta.analysis_cache_path
+    if not cache_path.exists():
+        return False
+    try:
+        payload = json.loads(cache_path.read_text(encoding="utf-8"))
+        cached_hash = payload.get("project_mtime_hash", "")
+        current_hash = _project_mtime_hash(root)
+        return cached_hash != current_hash
+    except Exception:
+        return False
+
+
+def _execute_add_anchor(action: Action, root: Path) -> ExecutionResult:
+    """앵커 없는 파일에 앵커 삽입."""
+    if not action.target_path:
+        return ExecutionResult(action, "skipped", "파일 경로 없음")
+    path = root / action.target_path
+    if not path.exists():
+        return ExecutionResult(action, "skipped", f"파일 없음: {action.target_path}")
+    try:
+        from vibelign.core.anchor_tools import extract_anchors, insert_module_anchors
+        if extract_anchors(path):
+            return ExecutionResult(action, "skipped", "이미 앵커 있음")
+        if insert_module_anchors(path):
+            try:
+                from vibelign.core.anchor_tools import generate_code_based_intents
+                generate_code_based_intents(root, [path])
+            except Exception as exc:
+                print(
+                    f"[WARN] code-based intent generation failed for {action.target_path}: {exc}",
+                    file=sys.stderr,
+                )
+                return ExecutionResult(
+                    action,
+                    "done",
+                    f"앵커 추가: {action.target_path} (code-based intent 생성 실패: {exc})",
+                )
+            # AI 보강은 vib anchor --auto-intent 로 별도 실행 (APPLY 블로킹 방지)
+            return ExecutionResult(action, "done", f"앵커 추가: {action.target_path}")
+        return ExecutionResult(action, "failed", "앵커 삽입 실패")
+    except Exception as e:
+        return ExecutionResult(action, "failed", str(e))
+
+
+def _execute_action(action: Action, root: Path) -> ExecutionResult:
+    if action.action_type == "add_anchor":
+        return _execute_add_anchor(action, root)
+    elif action.action_type in ("fix_mcp", "fix_project_map"):
+        cmd = action.command or "(명령어 없음)"
+        return ExecutionResult(action, "manual", f"수동 실행 필요: {cmd}")
+    else:
+        return ExecutionResult(action, "skipped", f"{action.action_type} — 수동 작업 필요")
+
+
+def execute_plan(plan: Plan, root: Path, force: bool = False, quiet: bool = False) -> ApplyResult:
+    """Plan을 실행한다.
+
+    Args:
+        plan: generate_plan()이 반환한 Plan
+        root: 프로젝트 루트
+        force: True면 확인 프롬프트 생략
+
+    Returns:
+        ApplyResult — needs_ai_aliases가 True면 GUI에서
+        ``vib anchor --auto-intent`` 를 비동기로 실행해야 한다.
+    """
+    from vibelign.terminal_render import clack_step, clack_info, clack_warn
+
+    def _q_step(msg: str) -> None:
+        if not quiet:
+            clack_step(msg)
+
+    def _q_info(msg: str) -> None:
+        if not quiet:
+            clack_info(msg)
+
+    def _q_warn(msg: str) -> None:
+        if not quiet:
+            clack_warn(msg)
+
+    # plan 이후 파일 변경 확인
+    if _check_plan_staleness(plan, root):
+        _q_warn(
+            "⚠️  분석 이후 파일이 변경됐습니다. "
+            "vib doctor --plan 을 다시 실행해 최신 계획을 확인하세요."
+        )
+        if not force:
+            try:
+                ans = input("  그래도 계속할까요? [y/N]: ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                return ApplyResult(checkpoint_id=None, aborted=True)
+            if ans not in ("y", "yes"):
+                return ApplyResult(checkpoint_id=None, aborted=True)
+
+    # 확인 프롬프트 (--force 없으면)
+    if not force:
+        print(f"\n  자동 적용 대상: {len(plan.actions)}개 항목")
+        try:
+            ans = input("\n  실행할까요? [y/N]: ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            return ApplyResult(checkpoint_id=None, aborted=True)
+        if ans not in ("y", "yes"):
+            return ApplyResult(checkpoint_id=None, aborted=True)
+
+    # 액션 실행
+    results: List[ExecutionResult] = []
+    for action in plan.actions:
+        result = _execute_action(action, root)
+        results.append(result)
+
+    # 코드 기반 aliases 항상 실행 (즉시, 비용 0) + AI 보강 필요 플래그
+    needs_ai = False
+    try:
+        from vibelign.core.anchor_tools import extract_anchors
+        from vibelign.core.project_scan import iter_source_files
+        anchored = [p for p in iter_source_files(root) if extract_anchors(p)]
+        if anchored:
+            from vibelign.core.anchor_tools import generate_code_based_intents
+            generate_code_based_intents(root, anchored)
+            needs_ai = True
+    except Exception as exc:
+        print(
+            f"[WARN] bulk code-based intent generation failed: {exc}",
+            file=sys.stderr,
+        )
+
+    # 분석 캐시 무효화 (파일이 변경됐으므로)
+    try:
+        from vibelign.core.meta_paths import MetaPaths
+        cache_path = MetaPaths(root).analysis_cache_path
+        if cache_path.exists():
+            cache_path.unlink()
+    except Exception as exc:
+        print(
+            f"[WARN] analysis cache cleanup failed: {exc}",
+            file=sys.stderr,
+        )
+
+    return ApplyResult(checkpoint_id=None, results=results, needs_ai_aliases=needs_ai)
+# === ANCHOR: ACTION_EXECUTOR_END ===

vibelign/action_engine/executors/checkpoint_bridge.py

@@ -0,0 +1,22 @@
+# === ANCHOR: CHECKPOINT_BRIDGE_START ===
+"""Checkpoint Bridge — apply 실행 전 자동 checkpoint 생성."""
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from vibelign.core.checkpoint_engine.contracts import CheckpointSummary
+from vibelign.core.checkpoint_engine.router import create_checkpoint
+
+
+def create_pre_apply_checkpoint(root: Path) -> Optional[CheckpointSummary]:
+    """--apply 실행 직전 자동으로 checkpoint를 생성한다.
+
+    Returns:
+        CheckpointSummary if created, None if no changes to snapshot.
+    """
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+    message = f"vibelign: checkpoint - apply 전 자동 저장 ({timestamp})"
+    return create_checkpoint(root, message)
+# === ANCHOR: CHECKPOINT_BRIDGE_END ===

vibelign/action_engine/generators/__init__.py

@@ -0,0 +1,3 @@
+# === ANCHOR: ACTION_ENGINE_GENERATORS_INIT_START ===
+"""Action Engine generators — 수정안 생성 (저장 금지)."""
+# === ANCHOR: ACTION_ENGINE_GENERATORS_INIT_END ===

vibelign/action_engine/generators/patch_generator.py

@@ -0,0 +1,102 @@
+# === ANCHOR: PATCH_GENERATOR_START ===
+"""Patch Generator — Plan의 각 Action에 대해 변경 예정 미리보기를 생성한다.
+
+patch_suggester.py를 재사용해 파일/앵커 위치를 찾는다.
+실제 파일 수정은 하지 않는다 — 미리보기만 생성.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from vibelign.action_engine.models.action import Action
+from vibelign.action_engine.models.plan import Plan
+
+
+def _preview_add_anchor(action: Action, root: Path) -> str:
+    """앵커 추가 예정 미리보기."""
+    if not action.target_path:
+        return "  파일 경로 미정 — vib anchor --suggest 실행 후 확인하세요."
+    path = root / action.target_path
+    if not path.exists():
+        return f"  {action.target_path} (파일 없음 — 경로 확인 필요)"
+    from vibelign.core.anchor_tools import extract_anchors
+    anchors = extract_anchors(path)
+    if anchors:
+        return f"  {action.target_path}\n  → 이미 앵커 있음: {', '.join(anchors[:3])}"
+    stem = path.stem.upper().replace("-", "_").replace(".", "_")
+    return (
+        f"  {action.target_path}\n"
+        f"  + # === ANCHOR: {stem}_START ===\n"
+        f"  + # === ANCHOR: {stem}_END ==="
+    )
+
+
+def _preview_fix_mcp(action: Action) -> str:
+    """MCP 설정 변경 예정 미리보기."""
+    cmd = action.command or "vib start --tools <tool>"
+    target = action.target_path or "설정 파일"
+    return (
+        f"  {target}\n"
+        f"  → 실행: {cmd}\n"
+        f"  → vibelign MCP 서버 항목이 추가됩니다."
+    )
+
+
+def _preview_fix_project_map(action: Action) -> str:
+    cmd = action.command or "vib start"
+    return (
+        f"  .vibelign/project_map.json 재생성\n"
+        f"  → 실행: {cmd}"
+    )
+
+
+def _preview_split_file(action: Action) -> str:
+    if not action.target_path:
+        return "  파일 경로 미정 — 앵커 추가 후 확인하세요."
+    return (
+        f"  {action.target_path}\n"
+        f"  → 기능별로 분리 예정 (앵커 확인 후 수동 또는 --apply로 실행)"
+    )
+
+
+def _preview_review(action: Action) -> str:
+    target = action.target_path or "(경로 미정)"
+    return f"  {target}\n  → 수동 검토 권장"
+
+
+def generate_patch_preview(plan: Plan, root: Path) -> str:
+    """Plan의 모든 Action에 대해 변경 예정 텍스트를 반환한다."""
+    if not plan.actions:
+        return "변경 예정 항목이 없습니다. 프로젝트 상태가 좋아요!\n"
+
+    lines = [
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "VibeLign 변경 예정 미리보기 (--patch)",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+        f"현재 점수: {plan.source_score} / 100  |  변경 예정: {len(plan.actions)}개",
+        "",
+    ]
+
+    for i, action in enumerate(plan.actions, 1):
+        lines.append(f"[{i}/{len(plan.actions)}] {action.action_type.upper()}")
+        lines.append(f"  이유: {action.description[:80]}")
+
+        if action.action_type == "add_anchor":
+            lines.append(_preview_add_anchor(action, root))
+        elif action.action_type == "fix_mcp":
+            lines.append(_preview_fix_mcp(action))
+        elif action.action_type == "fix_project_map":
+            lines.append(_preview_fix_project_map(action))
+        elif action.action_type == "split_file":
+            lines.append(_preview_split_file(action))
+        else:
+            lines.append(_preview_review(action))
+
+        lines.append("")
+
+    lines.append("※ 이 미리보기는 파일을 수정하지 않아요.")
+    lines.append("  실제 적용: vib doctor --apply")
+    return "\n".join(lines) + "\n"
+# === ANCHOR: PATCH_GENERATOR_END ===

vibelign/action_engine/models/__init__.py

@@ -0,0 +1,7 @@
+# === ANCHOR: ACTION_ENGINE_MODELS_INIT_START ===
+from vibelign.action_engine.models.issue import Issue
+from vibelign.action_engine.models.action import Action
+from vibelign.action_engine.models.plan import Plan
+
+__all__ = ["Issue", "Action", "Plan"]
+# === ANCHOR: ACTION_ENGINE_MODELS_INIT_END ===

vibelign/action_engine/models/action.py

@@ -0,0 +1,34 @@
+# === ANCHOR: ACTION_ENGINE_ACTION_START ===
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class Action:
+    action_type: str          # "add_anchor", "split_file", "fix_mcp", 등
+    description: str          # 사람이 읽을 수 있는 설명
+    target_path: Optional[str] = None   # 대상 파일 경로 (없을 수 있음)
+    command: Optional[str] = None       # 실행 가능한 CLI 명령어 (있을 경우)
+    depends_on: List[str] = field(default_factory=list)  # 먼저 실행되어야 할 action_type 목록
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "action_type": self.action_type,
+            "description": self.description,
+            "target_path": self.target_path,
+            "command": self.command,
+            "depends_on": self.depends_on,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Action":
+        return cls(
+            action_type=data["action_type"],
+            description=data["description"],
+            target_path=data.get("target_path"),
+            command=data.get("command"),
+            depends_on=data.get("depends_on", []),
+        )
+# === ANCHOR: ACTION_ENGINE_ACTION_END ===

vibelign/action_engine/models/issue.py

@@ -0,0 +1,31 @@
+# === ANCHOR: ACTION_ENGINE_ISSUE_START ===
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class Issue:
+    found: str
+    why_it_matters: str
+    next_step: str
+    path: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "found": self.found,
+            "why_it_matters": self.why_it_matters,
+            "next_step": self.next_step,
+            "path": self.path,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Issue":
+        return cls(
+            found=data["found"],
+            why_it_matters=data["why_it_matters"],
+            next_step=data["next_step"],
+            path=data.get("path"),
+        )
+# === ANCHOR: ACTION_ENGINE_ISSUE_END ===

vibelign/action_engine/models/plan.py

@@ -0,0 +1,33 @@
+# === ANCHOR: ACTION_ENGINE_PLAN_START ===
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+from vibelign.action_engine.models.action import Action
+
+
+@dataclass
+class Plan:
+    actions: List[Action]
+    source_score: int           # 분석 당시 project_score
+    generated_at: str           # ISO 8601 타임스탬프
+    warnings: List[str] = field(default_factory=list)  # 순환 의존 등 경고
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "actions": [a.to_dict() for a in self.actions],
+            "source_score": self.source_score,
+            "generated_at": self.generated_at,
+            "warnings": self.warnings,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Plan":
+        return cls(
+            actions=[Action.from_dict(a) for a in data.get("actions", [])],
+            source_score=data["source_score"],
+            generated_at=data["generated_at"],
+            warnings=data.get("warnings", []),
+        )
+# === ANCHOR: ACTION_ENGINE_PLAN_END ===

vibelign/cli/__init__.py

@@ -0,0 +1,5 @@
+# === ANCHOR: CLI_START ===
+from vibelign.cli.vib_cli import build_parser, main
+
+__all__ = ["build_parser", "main"]
+# === ANCHOR: CLI_END ===