@jahanxu/code-flow 0.1.0 → 0.2.0

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

@@ -1,150 +0,0 @@
-#!/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_learn.py

@@ -1,202 +0,0 @@
-#!/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_validate.py

@@ -1,340 +0,0 @@
-#!/usr/bin/env python3
-import fnmatch
-import json
-import os
-import subprocess
-import sys
-
-
-def load_validation(project_root: str) -> dict:
-    config_path = os.path.join(project_root, ".code-flow", "validation.yml")
-    if os.path.exists(config_path):
-        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 {}
-
-    package_path = os.path.join(project_root, "package.json")
-    if not os.path.exists(package_path):
-        return {}
-    try:
-        with open(package_path, "r", encoding="utf-8") as file:
-            data = json.load(file)
-    except Exception:
-        return {}
-
-    scripts = data.get("scripts") or {}
-    validators = []
-    if "lint" in scripts:
-        validators.append(
-            {
-                "name": "npm run lint",
-                "trigger": "**/*.{ts,tsx,js,jsx}",
-                "command": "npm run lint",
-                "timeout": 30000,
-                "on_fail": "检查 lint 配置",
-            }
-        )
-    if "test" in scripts:
-        validators.append(
-            {
-                "name": "npm test",
-                "trigger": "**/*.{ts,tsx,js,jsx}"
-                if "lint" in scripts
-                else "**/*.{ts,tsx,js,jsx,py}",
-                "command": "npm test",
-                "timeout": 60000,
-                "on_fail": "检查测试用例",
-            }
-        )
-
-    return {"validators": validators}
-
-
-def expand_pattern(pattern: str) -> list:
-    if "{" in pattern and "}" in pattern:
-        prefix, rest = pattern.split("{", 1)
-        options, suffix = rest.split("}", 1)
-        return [f"{prefix}{opt}{suffix}" for opt in options.split(",")]
-    return [pattern]
-
-
-def normalize_path(path: str) -> str:
-    return path.replace(os.sep, "/")
-
-
-def match_files(pattern: str, files: list) -> list:
-    matches = []
-    patterns = expand_pattern(pattern)
-    for file_path in files:
-        normalized = normalize_path(file_path)
-        for pat in patterns:
-            if "**/" in pat:
-                pat_variants = [pat, pat.replace("**/", "")]
-            else:
-                pat_variants = [pat]
-            for variant in pat_variants:
-                if fnmatch.fnmatch(normalized, variant):
-                    matches.append(file_path)
-                    break
-    return sorted(set(matches))
-
-
-def truncate(text: str, limit: int = 2000) -> str:
-    if len(text) <= limit:
-        return text
-    return text[:limit] + "..."
-
-
-def quote_single(path: str) -> str:
-    return "'" + path.replace("'", "'\"'\"'") + "'"
-
-
-def normalize_requested_files(
-    project_root: str,
-    requested: list,
-    require_exists: bool,
-) -> tuple:
-    normalized = []
-    root_abs = os.path.abspath(project_root)
-    for raw_path in requested:
-        if not raw_path:
-            continue
-        if os.path.isabs(raw_path):
-            abs_path = os.path.abspath(raw_path)
-        else:
-            abs_path = os.path.abspath(os.path.join(project_root, raw_path))
-        try:
-            common = os.path.commonpath([root_abs, abs_path])
-        except Exception:
-            return [], "invalid_path"
-        if common != root_abs:
-            return [], "outside_project_root"
-        if require_exists and not os.path.exists(abs_path):
-            return [], "file_missing"
-        rel_path = os.path.relpath(abs_path, project_root)
-        normalized.append(normalize_path(rel_path))
-    return sorted(set(normalized)), ""
-
-
-def main() -> None:
-    project_root = os.getcwd()
-    config = load_validation(project_root)
-    validators = config.get("validators") or []
-    if not validators:
-        print(json.dumps({"error": "validation_config_missing"}, ensure_ascii=False))
-        return
-
-    args = sys.argv[1:]
-    requested_files = []
-    for arg in args:
-        if arg.startswith("--files="):
-            raw = arg.split("=", 1)[1]
-            requested_files.extend([part.strip() for part in raw.split(",") if part.strip()])
-        elif arg in {"--json-short", "--only-failed"}:
-            continue
-        elif arg.startswith("--output="):
-            continue
-        else:
-            requested_files.append(arg)
-
-    git_dir = os.path.join(project_root, ".git")
-    has_git = os.path.isdir(git_dir)
-    files = []
-
-    if has_git:
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "HEAD"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        if result.returncode != 0:
-            print(
-                json.dumps(
-                    {"error": "git_diff_failed", "hint": "检查 git 仓库状态或 HEAD 是否存在"},
-                    ensure_ascii=False,
-                )
-            )
-            return
-        diff_files = [
-            normalize_path(line.strip())
-            for line in result.stdout.splitlines()
-            if line.strip()
-        ]
-        if requested_files:
-            normalized, error = normalize_requested_files(
-                project_root, requested_files, require_exists=False
-            )
-            if error:
-                print(
-                    json.dumps(
-                        {
-                            "error": "invalid_files",
-                            "hint": "确认文件路径位于项目根目录内",
-                        },
-                        ensure_ascii=False,
-                    )
-                )
-                return
-            diff_set = set(diff_files)
-            invalid = [path for path in normalized if path not in diff_set]
-            if invalid:
-                print(
-                    json.dumps(
-                        {
-                            "error": "files_not_in_diff",
-                            "hint": "仅允许使用 `git diff --name-only HEAD` 中的文件路径",
-                            "files": invalid,
-                        },
-                        ensure_ascii=False,
-                    )
-                )
-                return
-            files = normalized
-        else:
-            files = diff_files
-    else:
-        if not requested_files:
-            print(
-                json.dumps(
-                    {
-                        "error": "no_git_repo",
-                        "hint": "无 git 仓库时请通过 --files 或位置参数显式传入文件路径",
-                    },
-                    ensure_ascii=False,
-                )
-            )
-            return
-        normalized, error = normalize_requested_files(
-            project_root, requested_files, require_exists=True
-        )
-        if error:
-            print(
-                json.dumps(
-                    {
-                        "error": "invalid_files",
-                        "hint": "确认文件存在且位于项目根目录内",
-                    },
-                    ensure_ascii=False,
-                )
-            )
-            return
-        files = normalized
-
-    if not files:
-        print(json.dumps({"error": "no_files"}, ensure_ascii=False))
-        return
-
-    results = []
-    all_passed = True
-
-    for validator in validators:
-        name = validator.get("name", "unnamed")
-        trigger = validator.get("trigger", "")
-        command = validator.get("command", "")
-        timeout_ms = validator.get("timeout", 30000)
-        on_fail = validator.get("on_fail", "")
-
-        matched_files = match_files(trigger, files) if trigger else []
-        if not matched_files:
-            results.append(
-                {
-                    "name": name,
-                    "status": "skipped",
-                    "matched_files": [],
-                    "command": command,
-                }
-            )
-            continue
-
-        quoted_files = " ".join(quote_single(path) for path in matched_files)
-        run_command = command.replace("{files}", quoted_files)
-
-        try:
-            timeout = int(timeout_ms) / 1000
-        except Exception:
-            timeout = 30
-
-        status = "passed"
-        exit_code = 0
-        stdout = ""
-        stderr = ""
-
-        try:
-            proc = subprocess.run(
-                run_command,
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-            )
-            exit_code = proc.returncode
-            stdout = proc.stdout.strip()
-            stderr = proc.stderr.strip()
-            if exit_code != 0:
-                status = "failed"
-                all_passed = False
-        except subprocess.TimeoutExpired:
-            status = "timeout"
-            all_passed = False
-        except Exception:
-            status = "error"
-            all_passed = False
-
-        results.append(
-            {
-                "name": name,
-                "status": status,
-                "matched_files": matched_files,
-                "command": run_command,
-                "exit_code": exit_code,
-                "stdout": truncate(stdout),
-                "stderr": truncate(stderr),
-                "on_fail": on_fail,
-            }
-        )
-
-    output = {"passed": all_passed, "results": results}
-    if "--only-failed" in sys.argv:
-        output = {
-            "passed": all_passed,
-            "results": [
-                item
-                for item in results
-                if item["status"] in {"failed", "timeout", "error"}
-            ],
-        }
-
-    if "--json-short" in sys.argv:
-        output = {
-            "passed": all_passed,
-            "results": [
-                {
-                    "name": item["name"],
-                    "status": item["status"],
-                    "on_fail": item.get("on_fail", ""),
-                }
-                for item in output.get("results", [])
-            ],
-        }
-
-    if "--output=table" in sys.argv:
-        print("NAME | STATUS | MATCHED_FILES | COMMAND")
-        for item in output.get("results", []):
-            matched = ",".join(item.get("matched_files", []))
-            command = item.get("command", "")
-            print(f"{item.get('name')} | {item.get('status')} | {matched} | {command}")
-        return
-
-    print(json.dumps(output, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()