@michaelxwb/code-flow 0.6.4 → 0.8.1

package/src/core/code-flow/scripts/{cf_scan.py → codeflow/spec/cf_scan.py}

@@ -1,12 +1,14 @@
 #!/usr/bin/env python3
 import json
+import glob
 import os
 import re
 import sys
+from pathlib import Path
 
-import cf_log
-from cf_checks import load_check_state, parse_spec_checks
-from cf_core import (
+from codeflow.core import cf_log
+from codeflow.acceptance.cf_checks import load_check_state, parse_spec_checks
+from codeflow.core.cf_core import (
     build_effective_mapping,
     build_spec_catalog,
     estimate_tokens,
@@ -86,14 +88,30 @@ def normalize_line(line: str) -> str:
     return " ".join(line.strip().split())
 
 
+_YAML_STRUCTURE = re.compile(
+    r"^(?:stages:.*|enforcement:.*|verifiers:.*|tags:.*|tier:.*|"
+    r"- (?:design|plan|code|review)|-?\s*type:\s*(?:command|test))$"
+)
+
+
+def _audit_body(content: str) -> str:
+    """Remove only a complete frontmatter block at the start of the file."""
+    lines = content.splitlines()
+    if lines and lines[0].strip() == "---":
+        end = next((i for i in range(1, len(lines)) if lines[i].strip() == "---"), None)
+        if end is not None:
+            return "\n".join(lines[end + 1:])
+    return content
+
+
 def find_redundant_lines(specs: list) -> dict:
     line_map: dict = {}
     for spec in specs:
-        for raw in spec["content"].splitlines():
+        for raw in _audit_body(spec["content"]).splitlines():
             line = normalize_line(raw)
             if not line:
                 continue
-            if line.startswith("#") or line == "---":
+            if line.startswith("#") or line == "---" or _YAML_STRUCTURE.fullmatch(line):
                 continue
             if len(line) < 6:
                 continue
@@ -102,23 +120,73 @@ def find_redundant_lines(specs: list) -> dict:
     return redundant
 
 
-def find_missing_paths(text: str, project_root: str, base_dir: str = "") -> list:
-    """路径引用检查：项目根解析失败时，再按 spec 自身目录二次解析——
-    _map.md 常用相对本域目录的引用（如 design/design-lite.md）。"""
-    missing: list = []
-    for token in set(PATH_PATTERN.findall(text)):
-        if token.startswith("http://") or token.startswith("https://"):
+def _audit_options(config: dict) -> tuple[list[str], int]:
+    audit = config.get("audit", {})
+    if not isinstance(audit, dict):
+        raise ValueError("audit must be a mapping")
+    roots = audit.get("path_roots", [])
+    if not isinstance(roots, list) or any(not isinstance(root, str) or not root for root in roots):
+        raise ValueError("audit.path_roots must be a list of paths")
+    maximum = audit.get("long_spec_tokens", 500)
+    if type(maximum) is not int or maximum <= 0:
+        raise ValueError("audit.long_spec_tokens must be a positive integer")
+    return roots, maximum
+
+
+def _audit_roots(project_root: str, configured: list[str]) -> tuple[list[str], list[dict[str, str]]]:
+    project = Path(project_root).resolve()
+    roots: list[str] = []
+    warnings: list[dict[str, str]] = []
+    discovered = [path for pattern in ("apps/*/src/*", "packages/*/src/*", "lib/*/src/*")
+                  for path in sorted(glob.glob(str(project / pattern)))]
+    for value in [*configured, *discovered]:
+        candidate = (project / value).resolve()
+        if (candidate != project and project not in candidate.parents) or not candidate.is_dir() or not os.access(candidate, os.R_OK | os.X_OK):
+            if value in configured:
+                warnings.append({"code": "invalid_path_root", "path": value})
             continue
+        resolved = str(candidate)
+        if resolved not in roots:
+            roots.append(resolved)
+    return roots, warnings
+
+
+def _path_resolution(text: str, project_root: str, base_dir: str,
+                     roots: list[str]) -> tuple[list[str], dict[str, str]]:
+    missing: list[str] = []
+    resolved: dict[str, str] = {}
+    project = Path(project_root).resolve()
+    for token in _path_tokens(text):
+        candidates = [str(project), base_dir, *roots]
         if os.path.isabs(token):
-            if not os.path.exists(token):
-                missing.append(token)
-            continue
-        if os.path.exists(os.path.join(project_root, token)):
-            continue
-        if base_dir and os.path.exists(os.path.join(base_dir, token)):
+            candidates = [""]
+        for root in candidates:
+            if root and not Path(root).is_dir():
+                continue
+            target = Path(os.path.join(root, token)).resolve()
+            if not os.path.isabs(token) and target != project and project not in target.parents:
+                continue
+            if target.exists():
+                resolved[token] = os.path.relpath(root, project) if root else "/"
+                break
+        else:
+            missing.append(token)
+    return missing, resolved
+
+
+def _path_tokens(text: str) -> list[str]:
+    tokens: set[str] = set()
+    for word in re.findall(r"[^\s`<>()\"']+", text):
+        if "://" in word or any(char in word for char in "*?{}[]"):
             continue
-        missing.append(token)
-    return sorted(missing)
+        tokens.update(PATH_PATTERN.findall(word))
+    return sorted(tokens)
+
+
+def find_missing_paths(text: str, project_root: str, base_dir: str = "") -> list:
+    """路径引用检查：项目根解析失败时，再按 spec 自身目录二次解析——
+    _map.md 常用相对本域目录的引用（如 design/design-lite.md）。"""
+    return _path_resolution(text, project_root, base_dir, [])[0]
 
 
 def build_report(project_root: str, platform: str = "") -> dict:
@@ -165,6 +233,8 @@ def build_report(project_root: str, platform: str = "") -> dict:
     # 模板标记前置：模板（tags:[]）不参与冗长/冗余审计，也不把
     # 模板间共享的文档头计入其他文件的冗余计数
     config = load_config(project_root)
+    configured_roots, long_spec_tokens = _audit_options(config)
+    roots, audit_warnings = _audit_roots(project_root, configured_roots)
     effective_mapping = build_effective_mapping(
         project_root, config.get("path_mapping") or {}
     )
@@ -176,11 +246,11 @@ def build_report(project_root: str, platform: str = "") -> dict:
 
     for spec in specs:
         issues = []
-        if not spec["template"] and spec["tokens"] > 500:
+        if not spec["template"] and spec["tokens"] > long_spec_tokens:
             issues.append(f"冗长: {spec['tokens']} tokens")
 
         spec_dir = os.path.join(specs_root, os.path.dirname(spec.get("rel", "")))
-        missing_paths = find_missing_paths(spec["content"], project_root, spec_dir)
+        missing_paths, resolved_paths = _path_resolution(spec["content"], project_root, spec_dir, roots)
         for path in missing_paths[:3]:
             issues.append(f"过时: 路径不存在 {path}")
 
@@ -206,6 +276,7 @@ def build_report(project_root: str, platform: str = "") -> dict:
             "tokens": spec["tokens"],
             "issues": issues,
             "template": spec["template"],
+            "resolved_paths": resolved_paths,
         })
 
     for entry in files:
@@ -245,6 +316,7 @@ def build_report(project_root: str, platform: str = "") -> dict:
         "catalog": catalog_info,
         "review": review,
         "warnings": [],
+        "audit_warnings": audit_warnings,
     }
 
 

package/src/core/code-flow/scripts/codeflow/spec/cf_spec_budget.py

@@ -0,0 +1,55 @@
+"""Shared path-projection inputs and budget accounting."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Sequence
+
+from codeflow.core.cf_core import assemble_context, compress_content, estimate_tokens, load_config, parse_spec_frontmatter, resolve_compress
+from codeflow.spec.cf_spec_resolver import resolve_candidates
+
+
+class SpecBudgetError(ValueError):
+    def __init__(self, code: str, message: str) -> None:
+        self.code = code
+        super().__init__(message)
+
+
+def path_specs(root: str, paths: Sequence[str], compress: bool = True,
+               matched_only: bool = True) -> list[dict[str, object]]:
+    try:
+        candidates = resolve_candidates(root, 'code', tuple(paths), matched_only=matched_only)
+    except ValueError as exc:
+        raise SpecBudgetError('invalid_spec_metadata', str(exc)) from exc
+    specs: list[dict[str, object]] = []
+    for candidate in candidates:
+        if matched_only and candidate.scope == 'unmatched':
+            continue
+        target = Path(root) / '.code-flow/specs' / candidate.path
+        try:
+            raw = target.read_text(encoding='utf-8')
+        except OSError as exc:
+            raise SpecBudgetError('spec_read_failed', f'{candidate.path}: {exc}') from exc
+        _, content = parse_spec_frontmatter(raw)
+        final = compress_content(content.strip()) if compress else content.strip()
+        specs.append({'path': candidate.path, 'content': final, 'tier': 1})
+    return specs
+
+
+def measure_path_budget(root: str, paths: Sequence[str]) -> dict[str, object]:
+    config = load_config(root)
+    quality = config.get('quality_loop')
+    compress = resolve_compress(quality if isinstance(quality, dict) else {})
+    matched = path_specs(root, paths, compress) if paths else []
+    aggregate = path_specs(root, (), compress, matched_only=False)
+    text = assemble_context(matched, '## Active Specs (path-mapped)') if matched else ''
+    budget = config.get('budget', {})
+    if not isinstance(budget, dict):
+        raise SpecBudgetError('invalid_budget', 'budget must be a mapping')
+    limit = min(int(budget.get('total', 2500)), int(budget.get('l1_max', 1700)))
+    if limit <= 0:
+        raise SpecBudgetError('invalid_budget', 'budget limit must be positive')
+    total = estimate_tokens(text)
+    return {'matched_specs': [{'path': item['path'], 'tokens': estimate_tokens(item['content'])}
+                              for item in matched], 'matched_total': total,
+            'aggregate_total': sum(estimate_tokens(item['content']) for item in aggregate),
+            'limit': limit, 'over_limit': total > limit}