@xenonbyte/req-2-plan 0.2.3

package/tools/workflow_cli/tier.py

@@ -0,0 +1,201 @@
+# tools/workflow_cli/tier.py
+from __future__ import annotations
+from pathlib import Path
+from typing import Any
+import re
+import yaml
+
+from tools.workflow_cli.models import (
+    TierBase, TierModifier, TierEstimate, EvidenceBlock,
+)
+from tools.workflow_cli.repo_baseline import RepoBaseline
+from tools.workflow_cli.link_expander import LinkExpansionResult, LinkStatus
+
+_KEYWORDS_PATH = Path(__file__).parent / "tier_keywords.yaml"
+_keywords_cache: dict | None = None
+
+
+def _load_keywords() -> dict:
+    global _keywords_cache
+    if _keywords_cache is None:
+        with open(_KEYWORDS_PATH, encoding="utf-8") as f:
+            _keywords_cache = yaml.safe_load(f)
+    return _keywords_cache
+
+
+def _flatten_keywords(modifier_section: dict) -> list[str]:
+    """Flatten all keyword lists from a modifier section into one list."""
+    result = []
+    for value in modifier_section.values():
+        if isinstance(value, list):
+            result.extend(str(k) for k in value)
+        elif isinstance(value, dict):
+            result.extend(_flatten_keywords(value))
+    return result
+
+
+def _normalize(text: str) -> str:
+    """Normalize hyphens and lowercase."""
+    return re.sub(r'[-\s]+', ' ', text.lower()).strip()
+
+
+def _strip_hyphens(text: str) -> str:
+    """Strip hyphens (and surrounding spaces) to produce a compact form for hyphen-variant matching."""
+    return re.sub(r'\s*-\s*', '', text.lower())
+
+
+def _match_keyword(keyword: str, text: str, normalized_text: str) -> bool:
+    """Match a keyword against text. Multi-word phrases use substring; single words use word-boundary for English."""
+    kw_norm = _normalize(keyword)
+    # Chinese text: substring match
+    if re.search(r'[一-鿿]', keyword):
+        return keyword in text
+    # Multi-word: substring match on normalized text
+    if ' ' in kw_norm:
+        return kw_norm in normalized_text
+    # Single word: word boundary on normalized text
+    if re.search(r'\b' + re.escape(kw_norm) + r'\b', normalized_text, re.IGNORECASE):
+        return True
+    # Hyphen-variant fallback: strip all hyphens from both keyword and text and try word boundary
+    # This handles "reimplement" matching "re-implement" in the text
+    kw_compact = _strip_hyphens(keyword)
+    text_compact = _strip_hyphens(text)
+    return bool(re.search(r'\b' + re.escape(kw_compact) + r'\b', text_compact, re.IGNORECASE))
+
+
+def scan_keywords(text: str) -> dict[TierModifier, list[str]]:
+    """L1: scan text for modifier-triggering keywords. Returns {modifier: [matched keywords]}."""
+    keywords = _load_keywords()
+    normalized = _normalize(text)
+    hits: dict[TierModifier, list[str]] = {}
+
+    modifier_map = {
+        "migration": TierModifier.MIGRATION,
+        "cross_project": TierModifier.CROSS_PROJECT,
+        "safety": TierModifier.SAFETY,
+        "dependency": TierModifier.DEPENDENCY,
+        "scope_expanding": TierModifier.SCOPE_EXPANDING,
+    }
+
+    for section_name, modifier in modifier_map.items():
+        section = keywords.get(section_name, {})
+        section_keywords = _flatten_keywords(section)
+        matched = [kw for kw in section_keywords if _match_keyword(kw, text, normalized)]
+        if matched:
+            hits[modifier] = matched
+
+    return hits
+
+
+def compute_floor(
+    keyword_hits: dict[TierModifier, list[str]],
+    repo: RepoBaseline,
+    link_results: list[LinkExpansionResult],
+    requirement_text: str = "",
+) -> TierEstimate:
+    """Compute tier Floor from L1-L3 signals."""
+    # Base floor
+    base = TierBase.LIGHT
+
+    loc_threshold = 10_000
+    module_threshold = 8
+
+    if (
+        len(keyword_hits) > 0
+        or repo.loc > loc_threshold
+        or repo.is_monorepo
+        or repo.module_count > module_threshold
+        or _has_multi_repo_refs(requirement_text)
+        or any(r.status in (LinkStatus.UNREACHABLE, LinkStatus.REQUIRES_AUTH) for r in link_results)
+    ):
+        base = TierBase.STANDARD
+
+    # Modifier floor
+    modifiers: set[TierModifier] = set(keyword_hits.keys())
+
+    # Repo signals → cross_project modifier
+    if repo.cross_language_refs and len(repo.cross_language_refs) >= 2:
+        modifiers.add(TierModifier.CROSS_PROJECT)
+
+    # scope_expanding upgrades base to standard
+    if TierModifier.SCOPE_EXPANDING in modifiers and base == TierBase.LIGHT:
+        base = TierBase.STANDARD
+
+    return TierEstimate(base=base, modifiers=frozenset(modifiers))
+
+
+def _has_multi_repo_refs(text: str) -> bool:
+    """Check if requirement text mentions 2+ distinct repo names."""
+    repo_words = re.findall(r'\b(?:repo|repository|project)\s+\w+', text.lower())
+    return len(set(repo_words)) >= 2
+
+
+def build_evidence_block(
+    keyword_hits: dict[TierModifier, list[str]],
+    repo: RepoBaseline,
+    link_results: list[LinkExpansionResult],
+    floor: TierEstimate,
+) -> EvidenceBlock:
+    """Build the EvidenceBlock from all scan results."""
+    all_hits = [kw for hits in keyword_hits.values() for kw in hits]
+
+    repo_summary = (
+        f"loc={repo.loc}, modules={repo.module_count}, "
+        f"monorepo={repo.is_monorepo}, languages={list(repo.language_breakdown.keys())}"
+    )
+
+    linked_context_parts = []
+    for r in link_results:
+        if r.content_preview:
+            linked_context_parts.append(f"{r.url}: {r.content_preview[:100]}")
+    linked_context = "; ".join(linked_context_parts) if linked_context_parts else "none"
+
+    scope_signals = list(keyword_hits.get(TierModifier.SCOPE_EXPANDING, []))
+    escalation_candidates = [m.value for m in keyword_hits if m != TierModifier.SCOPE_EXPANDING]
+
+    return EvidenceBlock(
+        keywords_hit=all_hits,
+        repo_baseline_summary=repo_summary,
+        linked_context=linked_context,
+        scope_signals=scope_signals,
+        escalation_candidates=escalation_candidates,
+        floor=floor,
+        confirm_status="pending",
+    )
+
+
+def estimate_tier(
+    requirement_text: str,
+    repo_path: Path | None = None,
+    link_results: list[LinkExpansionResult] | None = None,
+) -> tuple[TierEstimate, EvidenceBlock]:
+    """Full tier estimation (L1-L4). Returns (estimate, evidence_block).
+
+    L1: keyword scan
+    L2: repo baseline
+    L3: link expansion (if link_results provided)
+    L4: Evidence Block completeness (caller must call evidence.validate_for_lock())
+    """
+    from tools.workflow_cli.repo_baseline import scan_repo_baseline
+
+    # L1: keyword scan
+    keyword_hits = scan_keywords(requirement_text)
+
+    # L2: repo baseline
+    if repo_path is not None and repo_path.exists():
+        repo = scan_repo_baseline(repo_path)
+    else:
+        from tools.workflow_cli.repo_baseline import RepoBaseline
+        repo = RepoBaseline()
+
+    # L3: link expansion (use provided results or empty)
+    if link_results is None:
+        link_results = []
+
+    # Compute floor
+    floor = compute_floor(keyword_hits, repo, link_results, requirement_text)
+
+    # Build evidence
+    evidence = build_evidence_block(keyword_hits, repo, link_results, floor)
+
+    return floor, evidence

package/tools/workflow_cli/tier_keywords.yaml

@@ -0,0 +1,45 @@
+# Tier modifier triggers.
+# Match rules:
+#   - English: word-boundary (\b), case-insensitive
+#   - Chinese: substring match (no word boundary)
+#   - Hyphen variants normalized: "re-write" matches "rewrite"
+
+migration:
+  verbs:
+    zh: [重写, 改写, 改成, 改用, 换成, 换用, 重做, 迁移, 移植, 转换, 转写, 升级到, 替代, 替换, 推倒重来]
+    en: [rewrite, rewriting, rewritten, migrate, migration, migrating, port to, porting, convert to, translate to, re-implement, reimplement, rebuild, replatform, modernize, refactor to]
+  nouns:
+    zh: [大版本升级, 技术栈迁移, 重写计划]
+    en: [major version upgrade, tech stack migration, rewrite plan]
+
+cross_project:
+  languages: [rust, go, golang, typescript, javascript, python, java, kotlin, swift, "c", "c++", cpp, "c#", csharp, ruby, php, scala, elixir, erlang, haskell, ocaml, lua, dart, zig, nim, clojure, r, julia]
+  frontend_frameworks: [react, vue, angular, svelte, solid, qwik, "next.js", nextjs, nuxt, remix, astro, ember]
+  backend_frameworks: [express, fastify, nestjs, django, flask, fastapi, rails, spring, laravel, gin, echo, axum, actix]
+  databases: [mysql, postgresql, postgres, mariadb, sqlite, mongodb, redis, cassandra, dynamodb, elasticsearch, clickhouse, timescaledb, neo4j, etcd, cockroachdb]
+  runtimes: ["node.js", nodejs, deno, bun, jvm, ".net", dotnet, wasm]
+  cloud: [aws, gcp, azure, aliyun, "alibaba cloud", "tencent cloud", cloudflare, vercel, netlify]
+  architecture: [monolith, microservices, monorepo, multirepo, serverless, edge, "service mesh"]
+  signals_zh: [项目, 仓库, 跨项目, 跨仓库, 两个项目, 多个项目, 多个仓库]
+  signals_en: [project, repo, repository, "across repos", "cross-project", monorepo]
+
+safety:
+  verbs:
+    zh: [删除, 删掉, 删表, 删库, 清理, 清除, 清空, 截断, 销毁, 下线, 关闭]
+    en: [delete, drop, truncate, purge, wipe, "remove data", destroy, retire, deprecate, "shut down"]
+  domains:
+    zh: [生产, 线上, 实时, 用户数据, 客户数据, 个人信息, 隐私, 敏感, 认证, 鉴权, 登录, 权限, 角色, 密钥, 凭证, 令牌, token, 支付, 计费, 订单, 财务, 退款, 不可逆, 破坏性]
+    en: [production, prod, live, "customer data", "user data", pii, privacy, sensitive, auth, authentication, authorization, login, permission, role, secret, credential, "api key", token, payment, billing, refund, order, financial, irreversible, "breaking change"]
+
+dependency:
+  verbs:
+    zh: [接入, 集成, 调用, 对接, 依赖]
+    en: [integrate, integrating, "call out to", "depend on", "external service"]
+  nouns:
+    zh: [第三方, 外部 api, sdk, mcp]
+    en: [third-party, "external api", sdk, mcp, "external service"]
+
+scope_expanding:
+  signals:
+    zh: [整个, 全部, 所有, 全套, 全部模块, 所有模块, 整套系统, 系统级, 全栈, 统一改造, 批量]
+    en: [entire, "all of", whole, full, everything, "system-wide", "across the board", comprehensive, sweeping]

package/tools/workflow_cli/version.py

@@ -0,0 +1 @@
+R2P_VERSION = "0.2.3"