greedy-token 0.2.1__py3-none-any.whl

greedy_token/__init__.py

@@ -0,0 +1,3 @@
+"""Greedy-token: route dev tasks before expensive LLM calls."""
+
+__version__ = "0.2.0"

greedy_token/__main__.py

@@ -0,0 +1,4 @@
+from greedy_token.cli import main
+
+if __name__ == "__main__":
+    main()

greedy_token/cli.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from greedy_token.context_audit import audit_context, render_audit
+from greedy_token.estimator import estimate_task, format_estimate
+from greedy_token.executors import execute_plan, plan_run
+from greedy_token.paths import find_monorepo_root
+from greedy_token.prompt_compress import compress_prompt, format_dual
+from greedy_token.rag_search import format_hits, search_rag
+from greedy_token.router import format_decision, route_task
+from greedy_token.tokens import TokenEstimate, collect_paths, count_files, format_size_table
+from greedy_token.wrappers import WRAPPERS, ollama_status_line, resolve_wrapper_command
+
+
+def cmd_route(args: argparse.Namespace) -> int:
+    root = find_monorepo_root()
+    decision = route_task(args.task, root)
+    print(format_decision(decision, args.task, root))
+    return 0
+
+
+def cmd_estimate(args: argparse.Namespace) -> int:
+    root = find_monorepo_root()
+    estimate = estimate_task(args.task, root)
+    print(format_estimate(estimate, args.task, root))
+    return 0
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    root = find_monorepo_root()
+    decision = route_task(args.task, root)
+    plan = plan_run(decision, args.task, root)
+    print(f"Route: {decision.target} ({decision.route_id})")
+    print(f"Complexity: {decision.complexity}  Est. tokens: {decision.est_tokens:,}")
+    print()
+    if args.execute:
+        code, out = execute_plan(plan)
+        print(out)
+        return code
+    print(plan.dry_run_output)
+    if plan.command:
+        if plan.executable:
+            print("\n(read-only — add --execute to run)")
+        else:
+            print("\n(not read-only — dry-run only)")
+    return 0
+
+
+def cmd_audit_context(_: argparse.Namespace) -> int:
+    items = audit_context()
+    print(render_audit(items))
+    return 0
+
+
+def cmd_tokens(args: argparse.Namespace) -> int:
+    root = find_monorepo_root()
+    paths = collect_paths(args.paths, root)
+    if not paths:
+        print("No files found.", file=sys.stderr)
+        return 1
+    estimates = count_files(paths)
+    rows = []
+    total_chars = 0
+    total_tokens = 0
+    method = "heuristic/4"
+    for p, est in zip(paths, estimates):
+        rel = str(p.relative_to(root)) if p.is_relative_to(root) else str(p)
+        rows.append((rel, est))
+        total_chars += est.chars
+        total_tokens += est.tokens
+        method = est.method
+    rows.sort(key=lambda r: -r[1].tokens)
+    total = TokenEstimate(tokens=total_tokens, chars=total_chars, method=method)
+    print(format_size_table(rows, total))
+    return 0
+
+
+def cmd_rag(args: argparse.Namespace) -> int:
+    root = find_monorepo_root()
+    domains = args.domain.split(",") if args.domain else None
+    hits = search_rag(args.query, root, domains=domains, limit=args.limit)
+    print(format_hits(args.query, hits))
+    return 0
+
+
+def cmd_compress(args: argparse.Namespace) -> int:
+    text = sys.stdin.read()
+    if not text.strip():
+        print("Read prompt from stdin.", file=sys.stderr)
+        return 1
+    short = compress_prompt(text, use_ollama=args.ollama)
+    if args.raw:
+        print(short)
+    else:
+        print(format_dual(text, short))
+    return 0
+
+
+def cmd_scripts(args: argparse.Namespace) -> int:
+    root = find_monorepo_root()
+    if args.list:
+        lines = ["Script wrappers (scripts/ollama | migrate | check-meta-sync):", ""]
+        for wrapper in WRAPPERS.values():
+            ro = "read-only" if wrapper.read_only else "writes"
+            oll = " +ollama" if wrapper.requires_ollama else ""
+            lines.append(f"  {wrapper.id:<20} [{wrapper.category}] {ro}{oll}")
+            lines.append(f"    {wrapper.path}")
+            if wrapper.note:
+                lines.append(f"    {wrapper.note}")
+        lines.append("")
+        lines.append(ollama_status_line())
+        print("\n".join(lines))
+        return 0
+    if args.run:
+        try:
+            cmd = resolve_wrapper_command(args.run, root, extra_args=args.args or "")
+        except (KeyError, FileNotFoundError) as exc:
+            print(exc, file=sys.stderr)
+            return 1
+        wrapper = WRAPPERS[args.run]
+        if args.execute:
+            if not wrapper.read_only:
+                print(
+                    f"Refusing --execute: {args.run} is not read-only.",
+                    file=sys.stderr,
+                )
+                return 1
+            import subprocess
+
+            proc = subprocess.run(cmd, shell=True)
+            return proc.returncode
+        print(cmd)
+        if wrapper.read_only:
+            print("\n(read-only — add --execute to run)")
+        else:
+            print("\n(not read-only — dry-run only)")
+        return 0
+    print("Use scripts --list or scripts --run ID", file=sys.stderr)
+    return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="greedy-token",
+        description="Task orchestrator: tool | Python | Ollama | RAG | Cursor",
+    )
+    sub = p.add_subparsers(dest="command", required=True)
+
+    r = sub.add_parser("route", help="Recommend executor for a task")
+    r.add_argument("task", help="Natural language task description")
+    r.set_defaults(func=cmd_route)
+
+    est = sub.add_parser("estimate", help="Token-aware route estimate with tier scan")
+    est.add_argument("task", help="Task description")
+    est.set_defaults(func=cmd_estimate)
+
+    run = sub.add_parser("run", help="Route and show/run command")
+    run.add_argument("task", help="Task description")
+    run.add_argument(
+        "--execute",
+        action="store_true",
+        help="Execute read-only tool/python commands only",
+    )
+    run.set_defaults(func=cmd_run)
+
+    sub.add_parser("audit-context", help="Token audit of rules/skills").set_defaults(
+        func=cmd_audit_context
+    )
+
+    t = sub.add_parser("tokens", help="Count tokens in paths")
+    t.add_argument("paths", nargs="+", help="Files or directories")
+    t.set_defaults(func=cmd_tokens)
+
+    rag = sub.add_parser("rag", help="Search docs/rag chunks")
+    rag.add_argument("query", help="Search query")
+    rag.add_argument("--domain", help="Comma-separated domains filter")
+    rag.add_argument("--limit", type=int, default=5)
+    rag.set_defaults(func=cmd_rag)
+
+    c = sub.add_parser("compress", help="Short agent prompt from stdin")
+    c.add_argument("--ollama", action="store_true", help="Use local Ollama")
+    c.add_argument("--raw", action="store_true", help="Print short text only")
+    c.set_defaults(func=cmd_compress)
+
+    scr = sub.add_parser("scripts", help="Wrappers for monorepo scripts")
+    scr.add_argument("--list", action="store_true", help="List script wrappers")
+    scr.add_argument("--run", metavar="ID", help="Wrapper id (e.g. check-meta-sync)")
+    scr.add_argument("args", nargs="?", default="", help="Extra args for script")
+    scr.add_argument(
+        "--execute",
+        action="store_true",
+        help="Run read-only wrapper only",
+    )
+    scr.set_defaults(func=cmd_scripts)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    code = args.func(args)
+    raise SystemExit(code)

greedy_token/config/routes.yaml

@@ -0,0 +1,156 @@
+# Task routing — aligned with docs/migration-prompts.md § Token economy rules
+#
+# Tier order (tool-first): tool → python → ollama → rag → cursor
+# First matching tier wins (best score within tier).
+
+routes:
+  - id: tool-rg-search
+    target: tool
+    tool: rg
+    read_only: true
+    patterns:
+      - find
+      - search for
+      - grep
+      - where is
+      - locate
+      - look for
+    note: "0 tokens — ripgrep before RAG/Cursor"
+
+  - id: tool-jq-manifest
+    target: tool
+    tool: jq
+    read_only: true
+    patterns:
+      - jq
+      - json field
+      - parse json
+      - phase-manifest json
+    json_path: docs/phase-manifest.json
+    jq_filter: .
+    note: "Structured JSON lookup — jq, 0 LLM"
+
+  - id: python-rsync
+    target: python
+    read_only: false
+    patterns:
+      - rsync
+      - migrate
+      - phase1-rsync
+      - mechanical copy
+      - bulk copy
+    command: ./scripts/migrate/phase1-rsync.sh
+    note: "0 tokens — shell rsync"
+
+  - id: python-meta-sync
+    target: python
+    read_only: true
+    patterns:
+      - check-meta-sync
+      - meta sync
+      - phase-manifest
+      - skills-map sync
+    command: ./scripts/check-meta-sync.sh
+    note: "Meta validation without LLM"
+
+  - id: python-gen-env
+    target: python
+    read_only: false
+    patterns:
+      - gen-env-configs
+      - env config generate
+      - properties sync script
+    command: python stacks/java-spring/scripts/gen-env-configs.py
+    note: "Deterministic config generation"
+
+  - id: ollama-inventory
+    target: ollama
+    read_only: false
+    patterns:
+      - batch inventory
+      - classify files
+      - file inventory
+      - migration inventory
+      - apply-inventory
+    command: ./scripts/ollama/batch-inventory.sh
+    note: "Bulk classify via local LLM"
+
+  - id: ollama-audit-skill
+    target: ollama
+    read_only: false
+    patterns:
+      - audit skill
+      - skill audit
+      - review skill md
+    command: ./scripts/ollama/audit-skill.sh
+    note: "Skill quality audit — Ollama, not Cursor"
+
+  - id: ollama-rag-draft
+    target: ollama
+    read_only: false
+    patterns:
+      - draft rag
+      - rag chunk draft
+      - batch rag
+      - ollama chunk
+    command: null
+    note: "Draft RAG chunks via scripts/ollama/ — never one-by-one in Cursor"
+
+  - id: rag-e2e-config
+    target: rag
+    patterns:
+      - e2e config
+      - -d flag
+      - testconfig
+      - env profile
+      - baseurl
+      - base url
+      - healthcheck
+      - gradle -d
+    domains: [e2e]
+    note: "Lookup docs/rag/e2e/e2e-config-keys.md, cfg-*"
+
+  - id: rag-e2e-patterns
+    target: rag
+    patterns:
+      - page object
+      - po locator
+      - selenide
+      - test pyramid
+      - test layer
+      - allure attach
+      - ci workflow
+      - allurerc
+    domains: [e2e, e2e-header]
+    note: "e2e patterns — read chunk, don't re-derive in chat"
+
+  - id: rag-stacks
+    target: rag
+    patterns:
+      - stack template
+      - openapi contract
+      - pyramid-map
+      - flows/login
+    domains: [stacks]
+    note: "stacks/_contract + docs/rag/stacks/"
+
+  - id: cursor-wiring
+    target: cursor
+    patterns:
+      - implement
+      - refactor
+      - fix bug
+      - add component
+      - header layout
+      - spring backend
+      - wiring
+      - architecture
+      - new feature
+      - e2e test class
+    note: "One chat = one zone; use skill if listed"
+
+cursor_fallback:
+  message: |
+    Нет точного match — скорее всего Cursor/Claude.
+    Проверь: один чат = одна зона (agent-scope.mdc).
+    Перед чатом: greedy-token audit-context && greedy-token rag "<topic>".

greedy_token/context_audit.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from greedy_token.paths import find_monorepo_root
+from greedy_token.tokens import TokenEstimate, count_files, format_size_table
+
+
+@dataclass
+class ContextItem:
+    path: str
+    kind: str
+    always_on: bool
+    estimate: TokenEstimate
+
+
+def audit_context(root: Path | None = None) -> list[ContextItem]:
+    root = root or find_monorepo_root()
+    items: list[ContextItem] = []
+
+    globs = [
+        (".cursor/rules/*.mdc", "rule", True),
+        (".cursor/skills/*/SKILL.md", "skill", False),
+        ("docs/CONTEXT.md", "doc", False),
+        ("docs/migration-prompts.md", "doc", False),
+    ]
+
+    found: list[tuple[Path, str, bool]] = []
+    for pattern, kind, always_on in globs:
+        for path in sorted(root.glob(pattern)):
+            if not path.is_file():
+                continue
+            found.append((path, kind, always_on))
+
+    estimates = count_files([f[0] for f in found])
+    for (path, kind, always_on), estimate in zip(found, estimates):
+        items.append(
+            ContextItem(
+                path=str(path.relative_to(root)),
+                kind=kind,
+                always_on=always_on,
+                estimate=estimate,
+            )
+        )
+
+    return items
+
+
+def render_audit(items: list[ContextItem]) -> str:
+    always = [i for i in items if i.always_on]
+    rules_total = sum(i.estimate.tokens for i in always)
+    skills_total = sum(i.estimate.tokens for i in items if i.kind == "skill")
+    all_total = sum(i.estimate.tokens for i in items)
+
+    lines = [
+        "== Cursor context audit ==",
+        "",
+        f"Always-on rules (.cursor/rules/*.mdc): {rules_total:,} tokens",
+        f"Skills on disk (.cursor/skills/*/SKILL.md): {skills_total:,} tokens",
+        f"Sampled docs: {all_total - rules_total - skills_total:,} tokens",
+        f"Grand total (sampled set): {all_total:,} tokens",
+        "",
+        "Always-on rules (charged every chat):",
+    ]
+
+    rule_rows = [
+        (i.path, i.estimate) for i in sorted(always, key=lambda x: -x.estimate.tokens)
+    ]
+    if rule_rows:
+        total = TokenEstimate(
+            tokens=rules_total,
+            chars=sum(i.estimate.chars for i in always),
+            method=always[0].estimate.method if always else "n/a",
+        )
+        lines.append(format_size_table(rule_rows, total))
+    else:
+        lines.append("  (none)")
+
+    lines.extend(["", "Top skills by size:"])
+    top_skills = sorted(
+        [i for i in items if i.kind == "skill"], key=lambda x: -x.estimate.tokens
+    )[:10]
+    for s in top_skills:
+        lines.append(f"  {s.estimate.tokens:>6}  {s.path}")
+
+    cache_hint = 1024
+    if rules_total >= cache_hint:
+        lines.extend(
+            [
+                "",
+                f"Note: always-on rules ({rules_total:,} tok) ≥ {cache_hint} —",
+                "stable prefix is cache-friendly for Claude API prompt caching.",
+            ]
+        )
+    elif rules_total > 0:
+        lines.extend(
+            [
+                "",
+                f"Note: always-on rules ({rules_total:,} tok) < {cache_hint} —",
+                "below typical prompt-cache minimum; keep rules slim.",
+            ]
+        )
+
+    return "\n".join(lines)

greedy_token/estimator.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from greedy_token.context_audit import audit_context
+from greedy_token.router import RouteDecision, route_task, route_task_all_tiers
+from greedy_token.tokens import count_tokens
+from greedy_token.wrappers import ollama_available, ollama_status_line
+
+
+TIER_ORDER = ("tool", "python", "ollama", "rag", "cursor")
+
+COMPLEXITY_BY_TARGET = {
+    "tool": "low",
+    "python": "low",
+    "ollama": "medium",
+    "rag": "low",
+    "cursor": "high",
+}
+
+BASE_CURSOR_OVERHEAD = 6000
+
+
+@dataclass
+class TaskEstimate:
+    decision: RouteDecision
+    complexity: str
+    est_tokens: int
+    rationale: str
+    cursor_saved: int
+    ollama_note: str | None = None
+
+
+def _cursor_baseline_tokens(root: Path) -> int:
+    items = audit_context(root)
+    return sum(i.estimate.tokens for i in items if i.always_on)
+
+
+def estimate_task(task: str, root: Path) -> TaskEstimate:
+    decision = route_task(task, root)
+    complexity = decision.complexity or COMPLEXITY_BY_TARGET.get(decision.target, "medium")
+    est_tokens = decision.est_tokens
+    rationale = decision.rationale
+    cursor_saved = 0
+    ollama_note: str | None = None
+
+    if decision.target != "cursor":
+        baseline = _cursor_baseline_tokens(root)
+        task_tokens = count_tokens(task).tokens
+        cursor_equiv = baseline + task_tokens + BASE_CURSOR_OVERHEAD
+        cursor_saved = max(0, cursor_equiv - est_tokens)
+
+    if decision.target == "ollama" and not ollama_available():
+        ollama_note = ollama_status_line()
+
+    return TaskEstimate(
+        decision=decision,
+        complexity=complexity,
+        est_tokens=est_tokens,
+        rationale=rationale,
+        cursor_saved=cursor_saved,
+        ollama_note=ollama_note,
+    )
+
+
+def format_estimate(estimate: TaskEstimate, task: str, root: Path) -> str:
+    d = estimate.decision
+    lines = [
+        f"Task: {task}",
+        f"Route: {d.target.upper()}  ({d.route_id}, {d.confidence:.0%})",
+        f"Complexity: {estimate.complexity}",
+        f"Est. Cursor tokens: {estimate.est_tokens:,}",
+        f"Rationale: {estimate.rationale}",
+    ]
+    if d.matched:
+        lines.append(f"Matched: {', '.join(d.matched)}")
+    if d.command:
+        cmd = d.command if d.command.startswith("cd ") else f"cd {root} && {d.command}"
+        lines.append(f"Command: {cmd}")
+    if estimate.cursor_saved > 0:
+        lines.append(f"Cursor tokens saved vs agent chat: ~{estimate.cursor_saved:,}")
+    if estimate.ollama_note:
+        lines.append(f"Note: {estimate.ollama_note}")
+    if d.target == "cursor":
+        lines.append("→ Новый Cursor-чат; skill из docs/skills-map.md если есть.")
+    lines.extend(["", "Tier scan:"])
+    for tier, decision in route_task_all_tiers(task, root):
+        if decision.matched:
+            tag = " ← selected" if decision.route_id == d.route_id else ""
+            lines.append(
+                f"  {tier:<8} {decision.route_id:<22} "
+                f"complexity={decision.complexity} est={decision.est_tokens:,}{tag}"
+            )
+        else:
+            lines.append(f"  {tier:<8} —")
+    return "\n".join(lines)

greedy_token/executors.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from greedy_token.paths import find_monorepo_root
+from greedy_token.rag_search import format_hits, search_rag
+from greedy_token.router import RouteDecision
+from greedy_token.wrappers import wrapper_for_command
+
+
+@dataclass
+class RunPlan:
+    decision: RouteDecision
+    command: str | None
+    dry_run_output: str
+    executable: bool
+
+
+def plan_run(decision: RouteDecision, task: str, root: Path | None = None) -> RunPlan:
+    root = root or find_monorepo_root()
+    target = decision.target
+
+    if target == "tool" and decision.command:
+        return RunPlan(
+            decision=decision,
+            command=decision.command,
+            dry_run_output=decision.command,
+            executable=decision.read_only,
+        )
+
+    if target == "python" and decision.command:
+        cmd = f"cd {root} && {decision.command}"
+        wrapper = wrapper_for_command(decision.command)
+        read_only = decision.read_only or (wrapper.read_only if wrapper else False)
+        return RunPlan(
+            decision=decision,
+            command=cmd,
+            dry_run_output=cmd,
+            executable=read_only,
+        )
+
+    if target == "ollama" and decision.command:
+        cmd = f"cd {root} && {decision.command}"
+        return RunPlan(
+            decision=decision,
+            command=cmd,
+            dry_run_output=cmd + "  # pass args as needed",
+            executable=False,
+        )
+
+    if target == "rag":
+        hits = search_rag(task, root, domains=decision.domains or None)
+        return RunPlan(
+            decision=decision,
+            command=None,
+            dry_run_output=format_hits(task, hits),
+            executable=False,
+        )
+
+    if target == "cursor":
+        return RunPlan(
+            decision=decision,
+            command=None,
+            dry_run_output=(
+                "Open new Cursor chat.\n"
+                f"Task: {task}\n"
+                "Before paste: greedy-token audit-context && greedy-token rag \"<topic>\""
+            ),
+            executable=False,
+        )
+
+    return RunPlan(
+        decision=decision,
+        command=None,
+        dry_run_output="No executor.",
+        executable=False,
+    )
+
+
+def execute_plan(plan: RunPlan) -> tuple[int, str]:
+    if not plan.command:
+        return 0, plan.dry_run_output
+    if not plan.executable:
+        return 1, (
+            "Refusing --execute: route is not read-only.\n"
+            f"Dry-run:\n{plan.dry_run_output}\n\n"
+            "Run the script manually if side effects are intended."
+        )
+    proc = subprocess.run(
+        plan.command,
+        shell=True,
+        capture_output=True,
+        text=True,
+    )
+    out = (proc.stdout or "") + (proc.stderr or "")
+    return proc.returncode, out or plan.dry_run_output

greedy_token/paths.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def find_monorepo_root(start: Path | None = None) -> Path:
+    env = os.environ.get("GREEDY_TOKEN_ROOT")
+    if env:
+        root = Path(env).expanduser().resolve()
+        if root.is_dir():
+            return root
+        raise SystemExit(f"GREEDY_TOKEN_ROOT is not a directory: {root}")
+
+    here = (start or Path(__file__)).resolve()
+    for parent in [here, *here.parents]:
+        if (parent / "docs" / "phase-manifest.json").is_file() and (
+            parent / "scripts" / "check-meta-sync.sh"
+        ).is_file():
+            return parent
+
+    raise SystemExit(
+        "Cannot find monorepo root. Set GREEDY_TOKEN_ROOT=/path/to/zero-design-system"
+    )
+
+
+def load_routes_config() -> dict:
+    import yaml
+
+    config_path = Path(__file__).parent / "config" / "routes.yaml"
+    with config_path.open(encoding="utf-8") as f:
+        return yaml.safe_load(f)