co-agent-coder 0.1.0__py3-none-any.whl

coagent/cli.py

@@ -0,0 +1,351 @@
+"""`coagent` command-line interface.
+
+v0.1 scope: `coagent init`, `coagent doctor`, `coagent config`. The run/resume/
+eval verbs land with the loop in milestone M1.
+"""
+
+from __future__ import annotations
+
+import argparse
+import platform
+import sys
+from pathlib import Path
+
+from . import __version__
+from .config import ConfigError, load_config, write_default_config
+
+
+def _cmd_init(args: argparse.Namespace) -> int:
+    try:
+        target = args.path or "."
+        path = write_default_config(Path(target), force=args.force)
+    except ConfigError as exc:
+        print(f"coagent: {exc}", file=sys.stderr)
+        return 1
+    print(f"wrote {path}")
+    added = _ensure_gitignore(Path(target))
+    if added:
+        print(f"added {len(added)} entr{'y' if len(added) == 1 else 'ies'} to .gitignore: {', '.join(added)}")
+    print("commit them so every session uses the same settings:")
+    print('  git add .coagent/config.toml .gitignore && git commit -m "chore: add coagent config"')
+    return 0
+
+
+_COAGENT_IGNORES = (
+    ".coagent/tmp/",
+    ".coagent/lock.json",
+    ".coagent/sessions/",
+    ".coagent/bundles/",
+    ".coagent/cache/",
+    ".coagent/secrets*",
+)
+
+
+def _ensure_gitignore(root: Path) -> list[str]:
+    """Add coAgent runtime ignores to a repo's .gitignore.
+
+    `coagent init` is an explicit setup action, so editing `.gitignore` here is
+    expected rather than a surprise. The session path warns instead of editing
+    (DESIGN §11).
+    """
+    ignore = root / ".gitignore"
+    try:
+        existing = ignore.read_text(encoding="utf-8") if ignore.is_file() else ""
+    except OSError:
+        return []
+    added = [entry for entry in _COAGENT_IGNORES if entry not in existing]
+    if not added:
+        return []
+    block = "\n# coAgent runtime state (config.toml and plans/ are committed)\n" + "\n".join(added) + "\n"
+    try:
+        with ignore.open("a", encoding="utf-8") as fh:
+            if existing and not existing.endswith("\n"):
+                fh.write("\n")
+            fh.write(block)
+    except OSError:
+        return []
+    return added
+
+
+def _cmd_resume(args: argparse.Namespace) -> int:
+    from .gitx import GitError, SessionError, build_briefing, open_session
+
+    repo_path = Path(args.repo or ".")
+    try:
+        session = open_session(repo_path, session_id=args.session, force=args.force)
+    except (SessionError, GitError) as exc:
+        print(f"coagent: {exc}", file=sys.stderr)
+        return 1
+    briefing = build_briefing(session.repo, session.session_id, session.branch)
+    # A briefing is read-only: never leave a lock behind from a diagnostic.
+    session.close()
+    print(briefing.render())
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "session": briefing.session_id,
+                    "branch": briefing.branch,
+                    "next_step": briefing.next_step,
+                    "committed_steps": briefing.committed_steps,
+                    "trailers": briefing.trailers,
+                    "plan": str(briefing.plan_path) if briefing.plan_path else None,
+                    "open_items": briefing.open_items,
+                    "dirty_paths": briefing.dirty_paths,
+                },
+                indent=2,
+            )
+        )
+    return 0
+
+
+def _cmd_doctor(args: argparse.Namespace) -> int:
+    cfg = load_config(args.config)
+    print(f"coagent {__version__}  (python {platform.python_version()}, {platform.system()})")
+    source = cfg.source or "(defaults — no .coagent/config.toml found)"
+    print(f"config:  {source}")
+    print(f"model:   {cfg.model.name} @ {cfg.model.quant}, ctx {cfg.model.max_context}")
+    print(f"verify:  {cfg.verify.commands}")
+    print(f"durable: {cfg.durability.mode} -> {cfg.durability.remote}")
+    try:
+        import torch  # noqa: F401
+    except ImportError:
+        torch = None  # type: ignore[assignment]
+    if torch is None:
+        print("torch:   not installed (install with `pip install coagent[llm]` in Colab)")
+        return 0
+    if not torch.cuda.is_available():
+        print("GPU:     none detected — coAgent runs on a free Colab T4 (PRD D-1)")
+        return 0
+    props = torch.cuda.get_device_properties(0)
+    name = props.name.replace("NVIDIA ", "")
+    print(f"GPU:     {name} · {props.total_memory / 1024**3:.0f} GB · CC {props.major}.{props.minor}")
+    if "T4" not in name or props.major < 7 or props.total_memory < 14 * 1024**3:
+        print("verdict: NOT a free-tier T4 envelope — preflight will refuse unless --allow-unsupported")
+    else:
+        print("verdict: OK for the coAgent T4 envelope")
+    return 0
+
+
+def _cmd_config(args: argparse.Namespace) -> int:
+    cfg = load_config(args.config)
+    if args.path:
+        print(cfg.source or "no .coagent/config.toml found")
+    elif args.effective:
+        print(cfg.to_toml())
+    else:
+        print(cfg.source or "no .coagent/config.toml found (using defaults)")
+        print(cfg.to_toml())
+    return 0
+
+
+def _cmd_tools(args: argparse.Namespace) -> int:
+    """Print the tool schemas for a phase — the exact contract the model sees."""
+
+    from .tools import PHASE_SAFETY, build_registry
+
+    cfg = load_config(args.config)
+    repo = Path(args.repo or ".").resolve()
+    if not repo.is_dir():
+        print(f"coagent: {repo} is not a directory", file=sys.stderr)
+        return 1
+    try:
+        if args.phase == "all":
+            for phase in PHASE_SAFETY:
+                names = build_registry(repo, cfg, phase=phase).names()
+                label = ", ".join(names) if names else "(none - plan cannot act)"
+                print(f"{phase:8s} ({len(names)}): {label}")
+            return 0
+        reg = build_registry(repo, cfg, phase=args.phase)
+    except ValueError as exc:
+        print(f"coagent: {exc}", file=sys.stderr)
+        return 1
+    if args.json:
+        print(reg.schemas_json())
+        return 0
+    print(f"phase {args.phase}: {len(reg)} tool(s)")
+    for schema in reg.schemas():
+        params = schema["parameters"]
+        required = set(params.get("required", []))
+        args_desc = ", ".join(
+            name if name in required else f"{name}?" for name in params["properties"]
+        )
+        print(f"  {schema['name']:12s} [{schema['safety']:5s}] ({args_desc})")
+        print(f"      {schema['description']}")
+    return 0
+
+
+def _cmd_models(args: argparse.Namespace) -> int:
+    from .llm import MODELS, preflight_gpu
+
+    cfg = load_config(args.config)
+    preflight = preflight_gpu() if args.gpu else None
+    if preflight is not None:
+        print(f"gpu:     {preflight.describe()}")
+        print(f"verdict: {'OK' if preflight.ok else 'REFUSED'}")
+        if not preflight.ok:
+            print(f"reason:  {preflight.reason}")
+        print()
+    print(f"configured: {cfg.model.name} @ {cfg.model.quant} · ctx {cfg.model.max_context}")
+    print()
+    for spec in MODELS.values():
+        mark = "*" if spec.name == cfg.model.name else " "
+        print(f" {mark} {spec.key:15s} {spec.trailer_id:40s} ctx {spec.max_context:>6d}  ~{spec.vram_gb:.1f} GB")
+        if spec.notes:
+            print(f"   {spec.notes}")
+    return 0
+
+
+def _cmd_run(args: argparse.Namespace) -> int:
+    """survey -> plan -> act -> verify -> checkpoint -> report, from the terminal."""
+    from .agent import coAgent as Agent
+
+    cfg = load_config(args.config)
+    repo = Path(args.repo or ".").resolve()
+    if not repo.is_dir():
+        print(f"coagent: {repo} is not a directory", file=sys.stderr)
+        return 1
+
+    backend = None
+    if args.dry_run:
+        # A scripted model: proves the plumbing without a GPU or a download.
+        from .llm import FakeBackend
+
+        backend = FakeBackend(_dry_run_script(args.task))
+
+    def on_event(kind: str, data: dict) -> None:
+        if kind == "tool":
+            mark = "ok  " if data.get("ok") else "FAIL"
+            print(f"  {mark} {data.get('tool')}")
+        elif kind == "plan":
+            print(f"  plan  {data.get('title')}  ({len(data.get('steps', []))} steps)")
+        elif kind == "commit":
+            print(f"  commit {str(data.get('sha'))[:8]} step {data.get('step')}")
+        elif kind == "sync":
+            print(f"  sync  {'ok' if data.get('ok') else 'warn'}: {data.get('message')}")
+        elif kind == "verify":
+            print(f"  verify {'passed' if data.get('ok') else 'failed'}")
+
+    try:
+        agent = Agent(
+            repo,
+            config=cfg,
+            backend=backend,
+            auto=args.auto or args.dry_run,
+            interactive=not args.auto,
+            token=None,
+            on_event=on_event,
+            force=args.force,
+            allow_unsupported=args.allow_unsupported,
+        )
+    except Exception as exc:  # noqa: BLE001 - every refusal is a message, not a traceback
+        print(f"coagent: {exc}", file=sys.stderr)
+        return 1
+
+    print(agent.status_line())
+    try:
+        result = agent.run(args.task)
+    except KeyboardInterrupt:
+        print("coagent: interrupted", file=sys.stderr)
+        return 130
+    finally:
+        agent.close()
+
+    print()
+    print(result.render())
+    return 0 if result.done else 2
+
+
+def _dry_run_script(task: str) -> list[str]:
+    """A scripted session so `--dry-run` exercises the real loop.
+
+    Deliberately ends without a further action: the run should stop cleanly on
+    "no more actions" rather than trip the loop detector, so the output shows a
+    normal early exit rather than a failure.
+    """
+    return [
+        "Surveyed the repository map. This is a dry run, so no model is loaded.",
+        "# dry run\n"
+        "- [ ] list the repository root\n"
+        "- [ ] run the configured checks",
+        '```json\n{"tool": "list_dir", "args": {"path": "."}}\n```',
+        # FakeBackend repeats its final response, so the script must say "stop"
+        # explicitly instead of relying on the queue running dry.
+        "The dry run is complete; no further action is needed.",
+    ]
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="coagent",
+        description="Private AI coding agent for the free Google Colab T4.",
+    )
+    parser.add_argument("--version", action="version", version=f"coagent {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_init = sub.add_parser("init", help="write a default .coagent/config.toml")
+    p_init.add_argument("path", nargs="?", help="repo root (default: current directory)")
+    p_init.add_argument("--force", action="store_true", help="overwrite an existing config")
+    p_init.set_defaults(func=_cmd_init)
+
+    p_doctor = sub.add_parser("doctor", help="report versions, GPU, cache state, verdict")
+    p_doctor.add_argument("--config", help="path to a config.toml (default: search upward)")
+    p_doctor.set_defaults(func=_cmd_doctor)
+
+    p_config = sub.add_parser("config", help="print the effective config")
+    p_config.add_argument("--config", help="path to a config.toml (default: search upward)")
+    p_config.add_argument("--path", action="store_true", help="print only the config path")
+    p_config.add_argument("--effective", action="store_true", help="print effective values as TOML")
+    p_config.set_defaults(func=_cmd_config)
+
+    p_tools = sub.add_parser("tools", help="list the tool schemas available per phase")
+    p_tools.add_argument("--config", help="path to a config.toml (default: search upward)")
+    p_tools.add_argument("--repo", help="repo root to jail against (default: cwd)")
+    p_tools.add_argument(
+        "--phase",
+        default="act",
+        choices=["survey", "plan", "act", "verify", "report", "all"],
+        help="phase to inspect (default: act)",
+    )
+    p_tools.add_argument("--json", action="store_true", help="print raw JSON schemas")
+    p_tools.set_defaults(func=_cmd_tools)
+
+    p_resume = sub.add_parser("resume", help="print the resume briefing for a session")
+    p_resume.add_argument("--repo", help="repo root (default: cwd)")
+    p_resume.add_argument("--session", help="session id to resume (default: from the branch)")
+    p_resume.add_argument("--force", action="store_true", help="take over a live lock")
+    p_resume.add_argument("--json", action="store_true", help="print the briefing as JSON")
+    p_resume.set_defaults(func=_cmd_resume)
+
+    p_models = sub.add_parser("models", help="list the validated models and check the GPU envelope")
+    p_models.add_argument("--config", help="path to a config.toml (default: search upward)")
+    p_models.add_argument("--gpu", action="store_true", help="run the T4 preflight check")
+    p_models.set_defaults(func=_cmd_models)
+
+    p_run = sub.add_parser("run", help="run one task: survey, plan, act, verify, report")
+    p_run.add_argument("task", help="what to do, in one sentence")
+    p_run.add_argument("--repo", help="repo root (default: cwd)")
+    p_run.add_argument("--config", help="path to a config.toml (default: search upward)")
+    p_run.add_argument("--auto", action="store_true", help="pre-approve the plan")
+    p_run.add_argument("--dry-run", action="store_true", help="use a scripted model (no GPU)")
+    p_run.add_argument("--force", action="store_true", help="take over a live session lock")
+    p_run.add_argument(
+        "--allow-unsupported",
+        action="store_true",
+        help="run on non-T4 hardware (unsupported, unvalidated)",
+    )
+    p_run.set_defaults(func=_cmd_run)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

coagent/config.py

@@ -0,0 +1,307 @@
+"""Configuration: load, validate, and version-check `.coagent/config.toml`.
+
+The config is committed to the target repo, so it must be reproducible and
+refuse to run when its schema is newer than this package understands
+(PRD FR-DIS-5).
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field, fields, is_dataclass
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover - Colab is 3.11+, this is for laptop dev
+    import tomli as tomllib
+
+SCHEMA_VERSION = 1
+CONFIG_RELPATH = Path(".coagent") / "config.toml"
+
+__all__ = [
+    "AgentConfig",
+    "ArtifactsConfig",
+    "ConfigError",
+    "Config",
+    "DurabilityConfig",
+    "GitConfig",
+    "ModelConfig",
+    "SafetyConfig",
+    "ToolsConfig",
+    "UIConfig",
+    "VerifyConfig",
+    "default_config_text",
+    "find_config",
+    "load_config",
+    "write_default_config",
+]
+
+
+class ConfigError(RuntimeError):
+    """Raised when the config is missing, malformed, or an unsupported schema."""
+
+
+@dataclass(slots=True)
+class ModelConfig:
+    name: str = "Qwen/Qwen2.5-Coder-7B-Instruct"
+    quant: str = "nf4"
+    max_context: int = 12288
+    max_new_tokens: int = 1024
+    temperature_edit: float = 0.2
+    temperature_plan: float = 0.7
+    top_p: float = 0.95
+    seed: int = 0  # 0 = pick a random seed at session start and log it
+    constrained: bool = False
+    fallback_name: str = "Qwen/Qwen2.5-Coder-3B-Instruct"
+    fallback_max_context: int = 8192
+
+    def __post_init__(self) -> None:
+        if self.max_context > 12288:
+            # PRD D2: the cap is hard, not advisory.
+            raise ConfigError(
+                f"model.max_context={self.max_context} exceeds the hard cap of 12288 "
+                "for the free T4 envelope (PRD D2)."
+            )
+        if self.quant not in {"nf4", "fp16"}:
+            raise ConfigError(f"model.quant must be 'nf4' or 'fp16', got {self.quant!r}.")
+
+
+@dataclass(slots=True)
+class VerifyConfig:
+    commands: list[str] = field(default_factory=lambda: ["ruff check .", "pytest -q"])
+    gpu_commands: list[str] = field(default_factory=list)
+    timeout_s: int = 300
+    vram_reserve_mb: int = 1024
+    require_tests: bool = True
+    feedback_max_tokens: int = 1500
+
+
+@dataclass(slots=True)
+class GitConfig:
+    author_name: str = "coAgent"
+    author_email: str = "coagent@users.noreply.github.com"
+    remotes: list[str] = field(default_factory=lambda: ["origin"])
+    clone_depth: int = 1
+    push_ref_prefix: str = "refs/heads/coagent/"
+
+
+@dataclass(slots=True)
+class DurabilityConfig:
+    mode: str = "push"
+    remote: str = "origin"
+    heartbeat_s: int = 180
+
+    def __post_init__(self) -> None:
+        if self.mode not in {"push", "bundle"}:
+            raise ConfigError(f"durability.mode must be 'push' or 'bundle', got {self.mode!r}.")
+
+
+@dataclass(slots=True)
+class AgentConfig:
+    max_steps: int = 60
+    max_wall_s: int = 2700
+    max_tokens: int = 200_000
+    max_gpu_min: int = 40
+    max_commits: int = 40
+    max_consecutive_failures: int = 3
+    replan_after_repeats: int = 3
+    stop_after_repeats: int = 5
+
+
+@dataclass(slots=True)
+class ToolsConfig:
+    allow_read: list[str] = field(default_factory=list)
+    max_output_bytes: int = 65536
+    shell_timeout_s: int = 120
+    notebook_timeout_s: int = 300
+
+
+@dataclass(slots=True)
+class ArtifactsConfig:
+    commit_under_mb: int = 5
+    store: str = "drive"
+    drive_dir: str = "coagent/artifacts"
+
+
+@dataclass(slots=True)
+class SafetyConfig:
+    require_approval: list[str] = field(
+        default_factory=lambda: ["network", "install", "delete", "write_outside_repo"]
+    )
+    deny: list[str] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class ContextConfig:
+    """Token slots for the 12k window (DESIGN §5.1).
+
+    Only the repo map slot is configurable so far; the rest of the ledger is
+    still assembled by the loop. Keeping the default equal to the design table
+    means an unconfigured repo behaves as specified.
+    """
+
+    repo_map_tokens: int = 2000
+    retrieved_tokens: int = 3000
+    max_files: int = 800
+
+    def __post_init__(self) -> None:
+        if self.repo_map_tokens < 200:
+            raise ConfigError(
+                f"context.repo_map_tokens={self.repo_map_tokens} is too small to be useful; "
+                "use at least 200 (DESIGN §5.1 gives the map 2000)."
+            )
+        if self.max_files < 1:
+            raise ConfigError(f"context.max_files must be >= 1, got {self.max_files}.")
+
+
+@dataclass(slots=True)
+class UIConfig:
+    mode: str = "show"
+    gradio: bool = False
+    gradio_port: int = 7860
+
+
+@dataclass(slots=True)
+class Config:
+    """The whole `.coagent/config.toml`, parsed and validated."""
+
+    schema_version: int = SCHEMA_VERSION
+    model: ModelConfig = field(default_factory=ModelConfig)
+    verify: VerifyConfig = field(default_factory=VerifyConfig)
+    git: GitConfig = field(default_factory=GitConfig)
+    durability: DurabilityConfig = field(default_factory=DurabilityConfig)
+    agent: AgentConfig = field(default_factory=AgentConfig)
+    tools: ToolsConfig = field(default_factory=ToolsConfig)
+    artifacts: ArtifactsConfig = field(default_factory=ArtifactsConfig)
+    safety: SafetyConfig = field(default_factory=SafetyConfig)
+    context: ContextConfig = field(default_factory=ContextConfig)
+    ui: UIConfig = field(default_factory=UIConfig)
+    source: Path | None = None
+
+    def to_toml(self) -> str:
+        return _dump_toml(self)
+
+
+_SECTIONS: dict[str, type] = {
+    "model": ModelConfig,
+    "verify": VerifyConfig,
+    "git": GitConfig,
+    "durability": DurabilityConfig,
+    "agent": AgentConfig,
+    "tools": ToolsConfig,
+    "artifacts": ArtifactsConfig,
+    "safety": SafetyConfig,
+    "context": ContextConfig,
+    "ui": UIConfig,
+}
+
+
+def _build_section(name: str, cls: type, data: Any) -> Any:
+    if not isinstance(data, dict):
+        raise ConfigError(f"[{name}] must be a table, got {type(data).__name__}.")
+    known = {f.name for f in fields(cls)}
+    unknown = set(data) - known
+    if unknown:
+        raise ConfigError(
+            f"[{name}] has unknown key(s): {', '.join(sorted(unknown))}. "
+            f"Known keys: {', '.join(sorted(known))}."
+        )
+    return cls(**data)
+
+
+def load_config(path: str | Path | None = None, *, start: str | Path | None = None) -> Config:
+    """Load and validate a config file.
+
+    With no `path`, searches upward from `start` (default: cwd) for
+    `.coagent/config.toml`. A missing file yields defaults so that
+    `coagent doctor` can run before the repo is initialised.
+    """
+    resolved = Path(path) if path is not None else find_config(start)
+    if resolved is None:
+        return Config()
+    try:
+        raw = tomllib.loads(resolved.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ConfigError(f"cannot read {resolved}: {exc}") from exc
+    except tomllib.TOMLDecodeError as exc:
+        raise ConfigError(f"{resolved} is not valid TOML: {exc}") from exc
+
+    version = raw.pop("schema_version", None)
+    if version is None:
+        raise ConfigError(f"{resolved} is missing schema_version (expected {SCHEMA_VERSION}).")
+    if not isinstance(version, int):
+        raise ConfigError(f"schema_version must be an integer, got {version!r}.")
+    if version > SCHEMA_VERSION:
+        raise ConfigError(
+            f"{resolved} uses schema_version {version}, but this coagent build "
+            f"understands {SCHEMA_VERSION}. Upgrade coagent, or regenerate the config "
+            "with `coagent init`."
+        )
+
+    cfg = Config(schema_version=version, source=resolved)
+    for key, value in raw.items():
+        cls = _SECTIONS.get(key)
+        if cls is None:
+            raise ConfigError(f"unknown top-level section [{key}] in {resolved}.")
+        setattr(cfg, key, _build_section(key, cls, value))
+    return cfg
+
+
+def find_config(start: str | Path | None = None) -> Path | None:
+    """Walk upward from `start` looking for `.coagent/config.toml`."""
+    current = Path(start or Path.cwd()).resolve()
+    for candidate in (current, *current.parents):
+        target = candidate / CONFIG_RELPATH
+        if target.is_file():
+            return target
+    return None
+
+
+def default_config_text() -> str:
+    """The shipped template, with its comments intact."""
+    return resources.files("coagent.templates").joinpath("config.toml").read_text(encoding="utf-8")
+
+
+def write_default_config(repo_root: str | Path, *, force: bool = False) -> Path:
+    """Write `.coagent/config.toml` into `repo_root`."""
+    target = Path(repo_root) / CONFIG_RELPATH
+    if target.exists() and not force:
+        raise ConfigError(f"{target} already exists; pass force=True to overwrite.")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(default_config_text(), encoding="utf-8")
+    return target
+
+
+def _dump_toml(cfg: Config) -> str:
+    """Minimal TOML writer (no dependency); enough for round-tripping a Config."""
+    lines = [f"schema_version = {cfg.schema_version}", ""]
+    for name, cls in _SECTIONS.items():
+        section = getattr(cfg, name)
+        lines.append(f"[{name}]")
+        for f in fields(cls):
+            value = getattr(section, f.name)
+            lines.append(f"{f.name} = {_toml_value(value)}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _toml_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return '0'  # TOML has no null; only used defensively
+    if isinstance(value, (int, float)):
+        return repr(value)
+    if isinstance(value, str):
+        return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    if isinstance(value, (list, tuple)):
+        return "[" + ", ".join(_toml_value(v) for v in value) + "]"
+    raise ConfigError(f"cannot serialise {type(value).__name__} to TOML")
+
+
+def is_dataclass_config(obj: Any) -> bool:
+    """Small helper used by tests and the doctor command."""
+    return is_dataclass(obj)

coagent/context/__init__.py

@@ -0,0 +1,26 @@
+"""Context layer: repo map, token budget, truncation (DESIGN §5).
+
+Context is the scarcest resource on a 12k window, so it gets its own ledger
+rather than being assembled ad hoc at each call site.
+"""
+
+from __future__ import annotations
+
+from .repo_map import DEFAULT_MAX_TOKENS, FileMap, RepoMap, RepoMapConfig, Signature
+from .retrieval import Chunk, Recalled, RetrievalConfig, Retriever
+from .tokens import estimate_tokens, fit, truncate_middle
+
+__all__ = [
+    "DEFAULT_MAX_TOKENS",
+    "Chunk",
+    "FileMap",
+    "Recalled",
+    "RepoMap",
+    "RepoMapConfig",
+    "RetrievalConfig",
+    "Retriever",
+    "Signature",
+    "estimate_tokens",
+    "fit",
+    "truncate_middle",
+]