zettcode 0.1.0__py3-none-any.whl

zettcode/__init__.py

@@ -0,0 +1,6 @@
+"""Terminal coding agent built on zett-agent."""
+
+from .config import ProviderName, ZettCodeConfig
+from .runtime import ZettCodeRuntime
+
+__all__ = ["ProviderName", "ZettCodeConfig", "ZettCodeRuntime"]

zettcode/cli.py

@@ -0,0 +1,78 @@
+"""Command-line entry point for the ZettCode TUI."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+from pathlib import Path
+
+from zett_agent import ReasoningEffort
+
+from .config import ProviderName, ZettCodeConfig, default_model, provider_api_key
+from .runtime import ZettCodeRuntime
+from .tui import ZettCodeTUI
+
+
+def parse_args(argv: list[str] | None = None) -> ZettCodeConfig:
+    """Parse CLI arguments into a validated immutable configuration."""
+    default_provider = os.getenv("ZETTCODE_PROVIDER") or ProviderName.DEEPSEEK.value
+    parser = argparse.ArgumentParser(description="Run the ZettCode terminal coding agent")
+    parser.add_argument("workspace", nargs="?", type=Path, default=Path.cwd())
+    parser.add_argument("--provider", choices=[item.value for item in ProviderName], default=default_provider)
+    parser.add_argument("--model")
+    parser.add_argument("--api-key", help="Prefer provider environment variables to avoid shell history exposure")
+    parser.add_argument("--base-url")
+    parser.add_argument("--responses-api", action="store_true")
+    parser.add_argument("--session")
+    parser.add_argument("--database", type=Path, default=Path.home() / ".zettcode" / "sessions.sqlite3")
+    parser.add_argument(
+        "--reasoning-effort",
+        choices=[item.value for item in ReasoningEffort],
+        default=ReasoningEffort.MEDIUM.value,
+    )
+    parser.add_argument("--serial-tools", action="store_true")
+    parser.add_argument("--max-iterations", type=int, default=36)
+    parser.add_argument("--compaction-max-tokens", type=int, default=128_000)
+    parser.add_argument("--compaction-keep-tokens", type=int, default=32_000)
+    args = parser.parse_args(argv)
+    try:
+        provider = ProviderName(args.provider)
+    except ValueError:
+        parser.error(f"Unsupported provider: {args.provider!r} (check ZETTCODE_PROVIDER)")
+    try:
+        return ZettCodeConfig(
+            workspace=args.workspace,
+            provider=provider,
+            model=args.model or default_model(provider),
+            api_key=args.api_key or provider_api_key(provider),
+            database=args.database,
+            session_id=args.session,
+            base_url=args.base_url,
+            responses_api=args.responses_api,
+            reasoning_effort=ReasoningEffort(args.reasoning_effort),
+            parallel_tool_call=not args.serial_tools,
+            max_iterations=args.max_iterations,
+            compaction_max_tokens=args.compaction_max_tokens,
+            compaction_keep_tokens=args.compaction_keep_tokens,
+        )
+    except ValueError as error:
+        parser.error(str(error))
+
+
+async def async_main(config: ZettCodeConfig) -> None:
+    """Own runtime lifecycle around the full-screen application."""
+    runtime = await ZettCodeRuntime.create(config)
+    try:
+        await ZettCodeTUI(runtime).run()
+    finally:
+        await runtime.aclose()
+
+
+def main() -> None:
+    """Installed console-script entry point."""
+    asyncio.run(async_main(parse_args()))
+
+
+if __name__ == "__main__":
+    main()

zettcode/config.py

@@ -0,0 +1,72 @@
+"""Validated construction settings for the ZettCode runtime."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+
+from zett_agent import ReasoningEffort
+
+
+class ProviderName(StrEnum):
+    """Provider adapters exposed by the initial CLI."""
+
+    DEEPSEEK = "deepseek"
+    OPENAI = "openai"
+
+
+@dataclass(frozen=True, slots=True)
+class ZettCodeConfig:
+    """All process-level settings needed to construct one coding runtime."""
+
+    workspace: Path
+    provider: ProviderName
+    model: str
+    api_key: str
+    database: Path
+    session_id: str | None = None
+    base_url: str | None = None
+    responses_api: bool = False
+    reasoning_effort: ReasoningEffort = ReasoningEffort.MEDIUM
+    parallel_tool_call: bool = True
+    max_iterations: int = 36
+    compaction_max_tokens: int = 128_000
+    compaction_keep_tokens: int = 32_000
+
+    def __post_init__(self) -> None:
+        workspace = self.workspace.expanduser().resolve()
+        database = self.database.expanduser().resolve()
+        if not workspace.is_dir():
+            raise ValueError(f"Workspace is not a directory: {workspace}")
+        if not self.model.strip():
+            raise ValueError("Model cannot be empty")
+        if not self.api_key.strip():
+            raise ValueError(f"Missing API key for {self.provider.value}")
+        if self.max_iterations < 1:
+            raise ValueError("max_iterations must be positive")
+        if self.compaction_keep_tokens < 1:
+            raise ValueError("compaction_keep_tokens must be positive")
+        if self.compaction_max_tokens <= self.compaction_keep_tokens:
+            raise ValueError("compaction_max_tokens must be greater than compaction_keep_tokens")
+        object.__setattr__(self, "workspace", workspace)
+        object.__setattr__(self, "database", database)
+
+
+def provider_api_key(provider: ProviderName) -> str:
+    """Read the selected provider credential without logging it."""
+    match provider:
+        case ProviderName.DEEPSEEK:
+            return os.getenv("DEEPSEEK_API_KEY") or os.getenv("DEEPSEEK_API", "")
+        case ProviderName.OPENAI:
+            return os.getenv("OPENAI_API_KEY", "")
+
+
+def default_model(provider: ProviderName) -> str:
+    """Return a conservative default model for one provider."""
+    match provider:
+        case ProviderName.DEEPSEEK:
+            return "deepseek-chat"
+        case ProviderName.OPENAI:
+            return "gpt-5-mini"

zettcode/runtime.py

@@ -0,0 +1,121 @@
+"""Application runtime that composes AgentClient with coding extensions."""
+
+from __future__ import annotations
+
+import os
+import platform
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+
+from zett_agent import (
+    AgentClient,
+    AgentRunConfig,
+    CodingExtension,
+    CompactionExtension,
+    DeepSeekProvider,
+    OpenAIProvider,
+    SQLiteSessionExtension,
+    ToolGuidelinesExtension,
+    create_agent,
+    new_uuid7,
+)
+
+from .config import ProviderName, ZettCodeConfig
+
+
+def build_system_prompt(config: ZettCodeConfig) -> str:
+    """Build request instructions with an explicit workspace boundary."""
+    now = datetime.now().astimezone()
+    return f"""You are ZettCode, a focused coding agent working with the user in one local workspace.
+
+Inspect relevant files before editing. Make focused changes, preserve unrelated work,
+and run checks proportional to risk. Explain blockers concretely. Do not perform
+destructive actions unless the user explicitly requests them.
+
+Runtime environment:
+- Workspace: {config.workspace}
+- Local time: {now.isoformat(timespec="seconds")}
+- Operating system: {platform.platform()}
+- Architecture: {platform.machine() or "unknown"}
+- Python: {platform.python_implementation()} {platform.python_version()}
+- Executable: {sys.executable}
+- Shell: {os.getenv("SHELL", "unknown")}
+
+Treat the workspace as the current working directory. Prefer relative paths in tool
+calls. Verify mutable facts with tools instead of assuming this startup snapshot is current."""
+
+
+@dataclass(slots=True)
+class ZettCodeRuntime:
+    """Own the model, persistence extension, AgentClient, and active session."""
+
+    config: ZettCodeConfig
+    client: AgentClient
+    persistence: SQLiteSessionExtension
+    model: OpenAIProvider | DeepSeekProvider
+    session_id: str
+
+    @classmethod
+    async def create(cls, config: ZettCodeConfig) -> ZettCodeRuntime:
+        """Create all owned resources after changing into the chosen workspace."""
+        os.chdir(config.workspace)
+        config.database.parent.mkdir(parents=True, exist_ok=True)
+        persistence = SQLiteSessionExtension(config.database)
+        recent = await persistence.list_sessions(limit=1)
+        session_id = config.session_id or (recent[0].session_id if recent else new_uuid7())
+        match config.provider:
+            case ProviderName.DEEPSEEK:
+                model = DeepSeekProvider(
+                    config.model,
+                    config.api_key,
+                    base_url=config.base_url,
+                    response=config.responses_api,
+                )
+            case ProviderName.OPENAI:
+                model = OpenAIProvider(
+                    config.model,
+                    config.api_key,
+                    base_url=config.base_url,
+                    response=config.responses_api,
+                )
+        try:
+            client = await create_agent(
+                model,
+                config=AgentRunConfig(session_id=session_id),
+                system_prompt=build_system_prompt(config),
+                extensions=[
+                    CodingExtension(),
+                    persistence,
+                    ToolGuidelinesExtension(),
+                    CompactionExtension(
+                        model,
+                        max_tokens=config.compaction_max_tokens,
+                        keep_recent_tokens=config.compaction_keep_tokens,
+                    ),
+                ],
+                reasoning_effort=config.reasoning_effort,
+                parallel_tool_call=config.parallel_tool_call,
+                max_iterations=config.max_iterations,
+            )
+        except BaseException:
+            await model.aclose()
+            await persistence.close()
+            raise
+        return cls(config, client, persistence, model, session_id)
+
+    def new_session(self) -> str:
+        """Switch future requests to a fresh session identity."""
+        self.session_id = new_uuid7()
+        return self.session_id
+
+    def use_session(self, session_id: str) -> None:
+        """Select a persisted or new explicit session for the next request."""
+        if not session_id.strip():
+            raise ValueError("Session ID cannot be empty")
+        self.session_id = session_id.strip()
+
+    async def aclose(self) -> None:
+        """Release all resources owned by this runtime."""
+        await self.model.aclose()
+        await self.persistence.close()