@jahanxu/code-flow 0.1.0

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

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import fnmatch
+
+from cf_core import (
+    assemble_context,
+    load_config,
+    load_inject_state,
+    match_domains,
+    read_specs,
+    save_inject_state,
+    select_specs,
+)
+
+
+def match_details(rel_path: str, mapping: dict) -> dict:
+    details = {}
+    for domain, cfg in (mapping or {}).items():
+        patterns = cfg.get("patterns") or []
+        for pattern in patterns:
+            if fnmatch.fnmatch(rel_path, pattern):
+                details[domain] = pattern
+                break
+    return details
+
+
+def main() -> None:
+    project_root = os.getcwd()
+    config = load_config(project_root)
+    if not config:
+        print(json.dumps({"error": "config_missing"}, ensure_ascii=False))
+        return
+
+    mapping = config.get("path_mapping") or {}
+    available_domains = sorted(mapping.keys())
+    args = sys.argv[1:]
+    list_specs = "--list-specs" in args
+    list_domain = ""
+    if list_specs:
+        for arg in args:
+            if arg.startswith("--domain="):
+                list_domain = arg.split("=", 1)[1]
+        if list_domain and list_domain in mapping:
+            specs = (mapping.get(list_domain) or {}).get("specs") or []
+            print(json.dumps({"domain": list_domain, "specs": specs}, ensure_ascii=False))
+            return
+        print(json.dumps({"error": "domain_not_found", "available_domains": available_domains}, ensure_ascii=False))
+        return
+    if not args:
+        state_path = os.path.join(project_root, ".code-flow", ".inject-state")
+        recent_target = ""
+        try:
+            with open(state_path, "r", encoding="utf-8") as file:
+                data = json.load(file)
+            recent_target = data.get("last_file", "")
+        except Exception:
+            recent_target = ""
+
+        if not recent_target:
+            print(
+                json.dumps(
+                    {
+                        "error": "missing_target",
+                        "available_domains": available_domains,
+                        "usage": "cf-inject <domain|file_path>",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return
+        target = recent_target
+    else:
+        target = args[0]
+    match_info = {}
+    if target in mapping:
+        domains = [target]
+    else:
+        abs_path = target
+        if not os.path.isabs(abs_path):
+            abs_path = os.path.join(project_root, target)
+        rel_path = os.path.relpath(abs_path, project_root)
+        domains = match_domains(rel_path, mapping)
+        match_info = match_details(rel_path, mapping)
+
+    if not domains:
+        print(
+            json.dumps(
+                {
+                    "error": "domain_not_found",
+                    "target": target,
+                    "available_domains": available_domains,
+                },
+                ensure_ascii=False,
+            )
+        )
+        return
+
+    specs = []
+    priorities = {}
+    for domain in domains:
+        domain_cfg = mapping.get(domain) or {}
+        priorities.update(domain_cfg.get("spec_priority") or {})
+        specs.extend(read_specs(project_root, domain, domain_cfg))
+
+    if not specs:
+        print(json.dumps({"error": "specs_empty", "domains": domains}, ensure_ascii=False))
+        return
+
+    budget_cfg = config.get("budget") or {}
+    budget = budget_cfg.get("l1_max", 1700)
+    try:
+        budget = int(budget)
+    except Exception:
+        budget = 1700
+
+    selected = select_specs(specs, budget, priorities)
+    if not selected:
+        print(json.dumps({"error": "budget_exceeded", "budget": budget}, ensure_ascii=False))
+        return
+
+    included_domains = {spec.get("domain") for spec in selected if spec.get("domain")}
+    state = load_inject_state(project_root)
+    injected_domains = state.get("injected_domains") or []
+    if not isinstance(injected_domains, list):
+        injected_domains = []
+    injected_domains = {d for d in injected_domains if isinstance(d, str)}
+    state_payload = {"injected_domains": sorted(injected_domains | included_domains)}
+    state_payload["last_file"] = target
+    save_inject_state(project_root, state_payload)
+
+    total_tokens = sum(spec.get("tokens", 0) for spec in selected)
+    output = {
+        "domains": sorted(included_domains),
+        "selected_specs": [
+            {"path": spec["path"], "tokens": spec["tokens"]} for spec in selected
+        ],
+        "total_tokens": total_tokens,
+        "budget": budget,
+        "context": assemble_context(selected, "## Active Specs"),
+    }
+    if os.environ.get("CF_DEBUG") == "1":
+        output["match_info"] = match_info
+        output["target"] = target
+    print(json.dumps(output, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+
+from cf_core import (
+    assemble_context,
+    is_code_file,
+    load_config,
+    load_inject_state,
+    match_domains,
+    read_specs,
+    save_inject_state,
+    select_specs,
+)
+
+
+def main() -> None:
+    try:
+        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
+
+        mapping = config.get("path_mapping") or {}
+        domains = match_domains(rel_path, mapping)
+        if not domains:
+            return
+
+        state = load_inject_state(project_root)
+        injected_domains = state.get("injected_domains") or []
+        if not isinstance(injected_domains, list):
+            injected_domains = []
+        injected_domains = {d for d in injected_domains if isinstance(d, str)}
+        new_domains = [domain for domain in domains if domain not in injected_domains]
+        if not new_domains:
+            state_payload = {"injected_domains": sorted(injected_domains)}
+            state_payload["last_file"] = abs_path
+            save_inject_state(project_root, state_payload)
+            return
+
+        specs = []
+        priorities = {}
+        for domain in new_domains:
+            domain_cfg = mapping.get(domain) or {}
+            priorities.update(domain_cfg.get("spec_priority") or {})
+            specs.extend(read_specs(project_root, domain, domain_cfg))
+
+        if not specs:
+            return
+
+        budget_cfg = config.get("budget") or {}
+        budget = budget_cfg.get("l1_max", 1700)
+        try:
+            budget = int(budget)
+        except Exception:
+            budget = 1700
+
+        selected = select_specs(specs, budget, priorities)
+        if not selected:
+            return
+
+        included_domains = {spec.get("domain") for spec in selected if spec.get("domain")}
+        state_payload = {"injected_domains": sorted(injected_domains | included_domains)}
+        state_payload["last_file"] = abs_path
+        save_inject_state(project_root, state_payload)
+
+        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(new_domains),
+            }
+        sys.stdout.write(json.dumps(payload))
+    except Exception:
+        return
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+import argparse
+import datetime
+import json
+import os
+import sys
+
+
+def load_config(project_root: str) -> dict:
+    config_path = os.path.join(project_root, ".code-flow", "config.yml")
+    if not os.path.exists(config_path):
+        return {}
+    try:
+        import yaml
+    except Exception:
+        return {}
+    try:
+        with open(config_path, "r", encoding="utf-8") as file:
+            data = yaml.safe_load(file)
+        return data or {}
+    except Exception:
+        return {}
+
+
+def read_text(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8") as file:
+            return file.read()
+    except Exception:
+        return ""
+
+
+def write_text(path: str, content: str) -> bool:
+    try:
+        with open(path, "w", encoding="utf-8") as file:
+            file.write(content)
+        return True
+    except Exception:
+        return False
+
+
+def estimate_tokens(text: str) -> int:
+    return len(text) // 4
+
+
+def find_target_spec(domain: str, config: dict, file_arg: str) -> tuple:
+    mapping = config.get("path_mapping") or {}
+    domain_cfg = mapping.get(domain) or {}
+    specs = domain_cfg.get("specs") or []
+    if not specs:
+        return "", specs
+    if file_arg:
+        if file_arg in specs:
+            return file_arg, specs
+        return "", specs
+    if len(specs) == 1:
+        return specs[0], specs
+    return "", specs
+
+
+def insert_learning(content: str, entry: str) -> str:
+    text = content.rstrip()
+    if not text:
+        return f"## Learnings\n{entry}\n"
+
+    lines = text.splitlines()
+    learn_index = None
+    for index, line in enumerate(lines):
+        if line.strip() == "## Learnings":
+            learn_index = index
+            break
+
+    if learn_index is None:
+        return f"{text}\n\n## Learnings\n{entry}\n"
+
+    insert_at = len(lines)
+    for idx in range(learn_index + 1, len(lines)):
+        if lines[idx].startswith("## "):
+            insert_at = idx
+            break
+
+    lines.insert(insert_at, entry)
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--scope", required=True, choices=["global", "frontend", "backend"])
+    parser.add_argument("--content", required=True)
+    parser.add_argument("--file", default="")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    project_root = os.getcwd()
+    config = load_config(project_root)
+
+    date_str = datetime.date.today().isoformat()
+    entry = f"- [{date_str}] {args.content.strip()}"
+
+    if args.scope == "global":
+        target_path = os.path.join(project_root, "CLAUDE.md")
+        content = read_text(target_path)
+        updated = insert_learning(content, entry)
+        if args.dry_run:
+            tokens = estimate_tokens(updated)
+            print(
+                json.dumps(
+                    {
+                        "status": "dry_run",
+                        "target": "CLAUDE.md",
+                        "entry": entry,
+                        "tokens": tokens,
+                        "warning": "L0 超出预算" if tokens > 800 else "",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return
+        if not write_text(target_path, updated):
+            print(json.dumps({"error": "write_failed", "target": "CLAUDE.md"}, ensure_ascii=False))
+            return
+        tokens = estimate_tokens(updated)
+        print(
+            json.dumps(
+                {
+                    "status": "ok",
+                    "target": "CLAUDE.md",
+                    "entry": entry,
+                    "tokens": tokens,
+                    "warning": "L0 超出预算" if tokens > 800 else "",
+                },
+                ensure_ascii=False,
+            )
+        )
+        return
+
+    if not config:
+        print(json.dumps({"error": "config_missing"}, ensure_ascii=False))
+        return
+
+    spec_rel, specs = find_target_spec(args.scope, config, args.file)
+    if not spec_rel:
+        print(
+            json.dumps(
+                {
+                    "error": "spec_not_selected",
+                    "available_specs": specs,
+                },
+                ensure_ascii=False,
+            )
+        )
+        return
+
+    target_path = os.path.join(project_root, ".code-flow", "specs", spec_rel)
+    content = read_text(target_path)
+    if not content:
+        print(
+            json.dumps(
+                {"error": "spec_missing_or_empty", "target": spec_rel},
+                ensure_ascii=False,
+            )
+        )
+        return
+
+    updated = insert_learning(content, entry)
+    tokens = estimate_tokens(updated)
+    warning = ""
+    if tokens > 500:
+        warning = "单文件超过 500 tokens，建议精简"
+    if args.dry_run:
+        print(
+            json.dumps(
+                {
+                    "status": "dry_run",
+                    "target": spec_rel,
+                    "entry": entry,
+                    "tokens": tokens,
+                    "warning": warning,
+                },
+                ensure_ascii=False,
+            )
+        )
+        return
+    if not write_text(target_path, updated):
+        print(json.dumps({"error": "write_failed", "target": spec_rel}, ensure_ascii=False))
+        return
+    print(
+        json.dumps(
+            {
+                "status": "ok",
+                "target": spec_rel,
+                "entry": entry,
+                "tokens": tokens,
+                "warning": warning,
+            },
+            ensure_ascii=False,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+import json
+import os
+import re
+import sys
+
+from cf_core import estimate_tokens, load_config
+
+
+PATH_PATTERN = re.compile(r"(?:[\w./-]+/)+[\w.-]+\.[A-Za-z0-9]+")
+
+
+def read_text(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8") as file:
+            return file.read().strip()
+    except Exception:
+        return ""
+
+
+def normalize_line(line: str) -> str:
+    return " ".join(line.strip().split())
+
+
+def find_redundant_lines(specs: list) -> dict:
+    line_map = {}
+    for spec in specs:
+        for raw in spec["content"].splitlines():
+            line = normalize_line(raw)
+            if not line:
+                continue
+            if line.startswith("#") or line == "---":
+                continue
+            if len(line) < 6:
+                continue
+            line_map.setdefault(line, set()).add(spec["path"])
+    redundant = {line: paths for line, paths in line_map.items() if len(paths) >= 3}
+    return redundant
+
+
+def find_missing_paths(text: str, project_root: str) -> list:
+    missing = []
+    for token in set(PATH_PATTERN.findall(text)):
+        if token.startswith("http://") or token.startswith("https://"):
+            continue
+        abs_path = token if os.path.isabs(token) else os.path.join(project_root, token)
+        if not os.path.exists(abs_path):
+            missing.append(token)
+    return sorted(missing)
+
+
+def main() -> None:
+    project_root = os.getcwd()
+    files = []
+    total_tokens = 0
+    json_output = "--json" in sys.argv
+    only_issues = "--only-issues" in sys.argv
+    limit = None
+    for arg in sys.argv[1:]:
+        if arg.startswith("--limit="):
+            try:
+                limit = int(arg.split("=", 1)[1])
+            except Exception:
+                limit = None
+
+    claude_path = os.path.join(project_root, "CLAUDE.md")
+    if os.path.exists(claude_path):
+        content = read_text(claude_path)
+        tokens = estimate_tokens(content)
+        total_tokens += tokens
+        files.append({"path": "CLAUDE.md", "tokens": tokens, "issues": []})
+
+    specs_root = os.path.join(project_root, ".code-flow", "specs")
+    specs = []
+    if os.path.isdir(specs_root):
+        for root, _, filenames in os.walk(specs_root):
+            for name in filenames:
+                if not name.endswith(".md"):
+                    continue
+                full_path = os.path.join(root, name)
+                content = read_text(full_path)
+                if not content:
+                    continue
+                tokens = estimate_tokens(content)
+                total_tokens += tokens
+                rel = os.path.relpath(full_path, specs_root)
+                rel_path = os.path.join("specs", rel).replace(os.sep, "/")
+                spec_entry = {
+                    "path": rel_path,
+                    "tokens": tokens,
+                    "issues": [],
+                    "content": content,
+                }
+                specs.append(spec_entry)
+
+    redundant_map = find_redundant_lines(specs)
+
+    for spec in specs:
+        issues = []
+        if spec["tokens"] > 500:
+            issues.append(f"冗长: {spec['tokens']} tokens")
+
+        missing_paths = find_missing_paths(spec["content"], project_root)
+        for path in missing_paths[:3]:
+            issues.append(f"过时: 路径不存在 {path}")
+
+        redundant_lines = [line for line, paths in redundant_map.items() if spec["path"] in paths]
+        for line in redundant_lines[:3]:
+            issues.append(f"冗余: '{line}' 出现于 {len(redundant_map[line])} 个文件")
+
+        files.append({"path": spec["path"], "tokens": spec["tokens"], "issues": issues})
+
+    for entry in files:
+        if total_tokens <= 0:
+            entry["percent"] = "0%"
+        else:
+            entry["percent"] = f"{round(entry['tokens'] * 100 / total_tokens)}%"
+
+    config = load_config(project_root)
+    budget = (config.get("budget") or {}).get("total", 2500)
+    try:
+        budget = int(budget)
+    except Exception:
+        budget = 2500
+
+    output = {
+        "files": files,
+        "total_tokens": total_tokens,
+        "budget": budget,
+        "warnings": [],
+    }
+    if limit is not None:
+        files = files[:limit]
+
+    if only_issues:
+        files = [entry for entry in files if entry.get("issues")]
+
+    if json_output:
+        output = {
+            "files": files,
+            "total_tokens": total_tokens,
+            "budget": budget,
+            "warnings": [],
+        }
+        print(json.dumps(output, ensure_ascii=False))
+        return
+
+    print("FILE | TOKENS | PERCENT | ISSUES")
+    for entry in files:
+        issues = entry.get("issues") or []
+        issue_text = " / ".join(issues) if issues else "-"
+        print(f"{entry['path']} | {entry['tokens']} | {entry['percent']} | {issue_text}")
+    print("TOTAL:", f"{total_tokens} / {budget}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+import os
+
+
+def main() -> None:
+    try:
+        project_root = os.getcwd()
+        state_path = os.path.join(project_root, ".code-flow", ".inject-state")
+        if os.path.exists(state_path):
+            os.remove(state_path)
+    except Exception:
+        return
+
+
+if __name__ == "__main__":
+    main()