@michaelxwb/code-flow 0.5.1 → 0.6.0

package/src/adapters/costrict/commands/cf-inject.md

@@ -1,55 +0,0 @@
-# cf-inject
-
-强制重新注入指定领域的编码规范（通常不需要手动调用）。
-
-## 自动注入机制
-
-本项目的规范注入是**全自动**的，通过两层机制保障：
-
-1. **CLAUDE.md 指令**：根据问题自动判断领域，读取 `_map.md` 导航地图理解项目结构
-2. **PreToolUse Hook**：编辑代码文件时根据文件路径标签自动注入匹配的约束 specs
-
-两层职责分离：CLAUDE.md 负责导航（Tier 0），Hook 负责约束注入（Tier 1）。
-
-正常情况下**无需手动调用**此命令。
-
-## 何时使用
-
-- 需要强制刷新已注入的规范（如 spec 文件刚被修改）
-- 想要预览某个领域的完整规范内容
-- 自动注入未生效时的排查手段
-- Hook 标签匹配遗漏了某些 spec，需要手动补充
-
-## 输入
-
-- `/project:cf-inject frontend` — 强制加载前端全部 specs
-- `/project:cf-inject backend` — 强制加载后端全部 specs
-
-## 执行步骤
-
-1. 用 Read 读取 `.code-flow/config.yml`，获取指定领域的 `specs` 列表
-2. 提取所有 spec 的 `path` 字段（兼容新旧格式）
-3. 按 tier 排序：tier 0（`_map.md`）在前，tier 1 按列表顺序
-4. 用 Read 逐个读取 `.code-flow/specs/` 下的匹配文件
-5. 将规范内容直接输出到对话中，格式：
-
-```
-## Active Specs (manual inject)
-
-### Navigation (Retrieval Map)
-
-#### [domain]/_map.md
-[导航地图内容]
-
-### Constraints (all specs for domain)
-
-#### [spec-path]
-[spec 内容]
-
----
-以上规范是本次开发的约束条件，生成代码必须遵循。
-```
-
-6. 用 Write 更新 `.code-flow/.inject-state`，将该域所有 spec 路径标记为已注入，防止 Hook 重复注入
-
-> 注：手动 inject 会加载该域的**全部** spec，不做标签过滤。这是与 Hook 自动注入的区别——Hook 按标签精准匹配，手动注入用于全量预览或强制刷新。

package/src/adapters/opencode/commands/cf-inject.md

@@ -1,59 +0,0 @@
----
-description: 强制重新注入指定领域的编码规范
----
-
-# cf-inject
-
-强制重新注入指定领域的编码规范（通常不需要手动调用）。
-
-## 自动注入机制
-
-本项目的规范注入是**全自动**的，通过两层机制保障：
-
-1. **AGENTS.md 指令**：AI 根据问题自动判断领域，读取 `_map.md` 导航地图理解项目结构
-2. **code-flow 插件**：在你发送消息时根据引用的文件自动注入匹配的约束 specs
-
-两层职责分离：AGENTS.md 负责导航（Tier 0），插件负责约束注入（Tier 1）。
-
-正常情况下**无需手动调用**此命令。
-
-## 何时使用
-
-- 需要强制刷新已注入的规范（如 spec 文件刚被修改）
-- 想要预览某个领域的完整规范内容
-- 自动注入未生效时的排查手段
-- 插件标签匹配遗漏了某些 spec，需要手动补充
-
-## 输入
-
-- `/project:cf-inject frontend` — 强制加载前端全部 specs
-- `/project:cf-inject backend` — 强制加载后端全部 specs
-
-## 执行步骤
-
-1. 读取 `.code-flow/config.yml`，获取指定领域的 `specs` 列表
-2. 提取所有 spec 的 `path` 字段（兼容新旧格式）
-3. 按 tier 排序：tier 0（`_map.md`）在前，tier 1 按列表顺序
-4. 逐个读取 `.code-flow/specs/` 下的匹配文件
-5. 将规范内容直接输出到对话中，格式：
-
-```
-## Active Specs (manual inject)
-
-### Navigation (Retrieval Map)
-
-#### [domain]/_map.md
-[导航地图内容]
-
-### Constraints (all specs for domain)
-
-#### [spec-path]
-[spec 内容]
-
----
-以上规范是本次开发的约束条件，生成代码必须遵循。
-```
-
-6. 更新 `.code-flow/.inject-state`，将该域所有 spec 路径标记为已注入，防止插件重复注入
-
-> 注：手动 inject 会加载该域的**全部** spec，不做标签过滤。这是与插件自动注入的区别——插件按标签精准匹配，手动注入用于全量预览或强制刷新。

package/src/core/code-flow/scripts/cf_inject_hook.py

@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-import json
-import os
-import sys
-
-import cf_log
-from cf_core import (
-    _log,
-    assemble_context,
-    build_effective_mapping,
-    debug_log,
-    ensure_utf8_io,
-    extract_context_tags,
-    fallback_domains_for_context,
-    is_code_file,
-    load_config,
-    load_inject_state,
-    match_domains,
-    match_specs_by_tags,
-    read_matched_specs,
-    resolve_compress,
-    resolve_quality_loop,
-    resolve_session_id,
-    save_inject_state,
-    select_specs_tiered,
-)
-
-
-
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        raw = sys.stdin.read()
-        if not raw.strip():
-            return
-        data = json.loads(raw)
-        tool_name = data.get("tool_name", "")
-        tool_input = data.get("tool_input") or {}
-        file_path = tool_input.get("file_path", "")
-        if tool_name not in {"Edit", "Write", "MultiEdit"}:
-            return
-        if not isinstance(file_path, str) or not file_path:
-            return
-
-        project_root = os.getcwd()
-        abs_path = file_path
-        if not os.path.isabs(abs_path):
-            abs_path = os.path.join(project_root, file_path)
-        rel_path = os.path.relpath(abs_path, project_root)
-
-        config = load_config(project_root)
-        if not config:
-            return
-        inject_config = config.get("inject") or {}
-        if inject_config.get("auto") is False:
-            return
-        if not is_code_file(rel_path, inject_config):
-            return
-        compress_enabled = resolve_compress(inject_config)
-
-        mapping = config.get("path_mapping") or {}
-        effective_mapping = build_effective_mapping(project_root, mapping)
-        domains = match_domains(rel_path, effective_mapping)
-
-        sid = resolve_session_id(data)
-
-        # Quality-loop instrumentation (FEAT-00): every code-file edit is an
-        # event — correction pairing and stop-check need them even when no
-        # spec matches below. append_event never raises (hot path safe).
-        quality_loop = resolve_quality_loop(config)
-        if quality_loop["enabled"]:
-            cf_log.append_event(
-                project_root, "edit",
-                {"file": rel_path.replace(os.sep, "/"), "tool": tool_name},
-                sid,
-            )
-
-        # Extract context tags from file path
-        context_tags = extract_context_tags(rel_path)
-        if not domains:
-            domains = sorted(fallback_domains_for_context(effective_mapping, context_tags))
-            if not domains:
-                return
-
-        # Budget config
-        budget_cfg = config.get("budget") or {}
-        l1_budget = 1700
-        map_max = 400
-        try:
-            l1_budget = int(budget_cfg.get("l1_max", 1700))
-        except (ValueError, TypeError):
-            pass
-        try:
-            map_max = int(budget_cfg.get("map_max", 400))
-        except (ValueError, TypeError):
-            pass
-
-        # Strict tag-based matching per domain. No bulk-load fallback: when a
-        # Tier 1 spec's tags don't intersect context_tags, the spec is NOT
-        # injected. Tier 0 (_map.md) uses the "*" wildcard so it still reaches
-        # the model as navigation. Re-inject every call (session dedup removed).
-        all_matched = []
-        for domain in domains:
-            domain_cfg = effective_mapping.get(domain) or {}
-            specs_config = domain_cfg.get("specs") or []
-            matched, _ = match_specs_by_tags(specs_config, context_tags)
-            if matched:
-                specs = read_matched_specs(
-                    project_root, domain, matched, compress=compress_enabled
-                )
-                all_matched.extend(specs)
-
-        if not all_matched:
-            return
-
-        selected = select_specs_tiered(all_matched, l1_budget, map_max)
-        if not selected:
-            return
-
-        # Load state with session isolation (deferred until after match success)
-        state = load_inject_state(project_root)
-        same_session = state.get("session_id") == sid
-        if same_session:
-            injected_specs = set(state.get("injected_specs") or [])
-        else:
-            injected_specs = set()
-
-        # Update state with newly injected spec paths. Preserve
-        # UserPromptSubmit-owned fields (prompt_count / prompt_inject_window)
-        # verbatim so cross-hook writes don't reset the dedup window.
-        new_injected = injected_specs | {s["path"] for s in selected}
-        debug_log(f"inject_hook injected={[s['path'] for s in selected]} path={rel_path}", project_root)
-        new_state = {
-            "session_id": sid,
-            "injected_specs": sorted(new_injected),
-            "last_file": abs_path,
-        }
-        if same_session:
-            if "prompt_count" in state:
-                new_state["prompt_count"] = state["prompt_count"]
-            if "prompt_inject_window" in state:
-                new_state["prompt_inject_window"] = state["prompt_inject_window"]
-        save_inject_state(project_root, new_state)
-
-        if quality_loop["enabled"]:
-            cf_log.append_event(
-                project_root, "inject",
-                {"specs": [s["path"] for s in selected],
-                 "mode": "full", "source": "pretooluse"},
-                sid,
-            )
-
-        payload = {
-            "hookSpecificOutput": {
-                "hookEventName": "PreToolUse",
-                "additionalContext": assemble_context(
-                    selected, "## Active Specs (auto-injected)"
-                ),
-            }
-        }
-        if os.environ.get("CF_DEBUG") == "1":
-            payload["debug"] = {
-                "target": abs_path,
-                "domains": sorted(domains),
-                "context_tags": sorted(context_tags),
-                "matched_specs": [s["path"] for s in selected],
-            }
-        sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-    except Exception as exc:
-        # Fix #9: log errors to stderr instead of silently swallowing
-        _log(f"cf_inject_hook error: {exc}")
-        return
-
-
-if __name__ == "__main__":
-    main()

package/src/core/code-flow/scripts/cf_session_hook.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""SessionStart hook: reset .inject-state for the new session.
-
-Reads the session_id from the hook payload (stdin JSON) so the value matches
-what PreToolUse / UserPromptSubmit will write later — keeping the
-"hook id 优先、回退 PID" contract in cf_core.resolve_session_id consistent
-across the session. If stdin is empty (older runtime, unit test) we fall back
-to the current PID; the next hook with a real session_id will then trigger
-the normal session-mismatch reset path, so behavior degrades gracefully.
-"""
-import json
-import os
-import sys
-
-from cf_core import ensure_utf8_io, resolve_session_id
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        raw = sys.stdin.read()
-        data = json.loads(raw) if raw and raw.strip() else {}
-        if not isinstance(data, dict):
-            data = {}
-        sid = resolve_session_id(data)
-
-        project_root = os.getcwd()
-        state_path = os.path.join(project_root, ".code-flow", ".inject-state")
-        os.makedirs(os.path.dirname(state_path), exist_ok=True)
-        payload = {
-            "session_id": sid,
-            "injected_specs": [],
-            "last_file": "",
-        }
-        with open(state_path, "w", encoding="utf-8") as f:
-            json.dump(payload, f)
-    except Exception:
-        return
-
-
-if __name__ == "__main__":
-    main()