agencode 0.1.0__py3-none-any.whl

agencli/tui/trace.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from textual.widgets import DataTable
+
+from agencli.agents.runtime import StreamEvent
+
+
+TRACE_ROW_LIMIT = 40
+
+
+@dataclass(slots=True)
+class TraceRow:
+    step: int
+    kind: str
+    label: str
+    status: str
+    detail: str
+
+
+@dataclass(slots=True)
+class OrchestrationRow:
+    name: str
+    role: str
+    tools: str
+    status: str
+    detail: str
+
+
+class TraceLedger:
+    def __init__(self, max_rows: int = TRACE_ROW_LIMIT) -> None:
+        self.max_rows = max_rows
+        self.rows: list[TraceRow] = []
+        self._next_step = 1
+        self._active_tools: dict[str, TraceRow] = {}
+        self._active_subagents: dict[str, TraceRow] = {}
+
+    def reset(self) -> None:
+        self.rows.clear()
+        self._active_tools.clear()
+        self._active_subagents.clear()
+        self._next_step = 1
+
+    def begin_run(self, agent_name: str, thread_id: str) -> None:
+        self.reset()
+        self.add_status(label=agent_name, status="thread", detail=thread_id, kind="session")
+
+    def add_status(self, *, label: str, status: str, detail: str, kind: str = "state") -> None:
+        self._append_row(kind=kind, label=label, status=status, detail=detail)
+
+    def record(self, event: StreamEvent) -> None:
+        if event.kind == "assistant":
+            return
+        if event.kind == "tool":
+            self._record_tool_event(event)
+            return
+        if event.kind == "subagent":
+            self._record_subagent_event(event)
+            return
+        self._append_row(
+            kind=event.kind,
+            label=event.label,
+            status=event.phase or "update",
+            detail=event.text or "(ok)",
+        )
+
+    def _record_tool_event(self, event: StreamEvent) -> None:
+        tool_key = event.trace_id or event.label
+        if event.phase == "start":
+            row = self._append_row(
+                kind="tool",
+                label=event.label,
+                status="running",
+                detail=event.text or "invoked",
+            )
+            self._active_tools[tool_key] = row
+            return
+
+        existing = self._active_tools.pop(tool_key, None)
+        if existing is None:
+            self._append_row(
+                kind="tool",
+                label=event.label,
+                status="done",
+                detail=event.text or "(ok)",
+            )
+            return
+
+        existing.status = "done"
+        existing.detail = _merge_detail(existing.detail, event.text or "(ok)")
+
+    def _record_subagent_event(self, event: StreamEvent) -> None:
+        subagent_key = event.trace_id or event.label
+        if event.phase == "start":
+            row = self._append_row(
+                kind="subagent",
+                label=event.label,
+                status="running",
+                detail=event.text or "delegated",
+            )
+            self._active_subagents[subagent_key] = row
+            return
+
+        existing = self._active_subagents.pop(subagent_key, None)
+        if existing is None:
+            self._append_row(
+                kind="subagent",
+                label=event.label,
+                status="done",
+                detail=event.text or "(ok)",
+            )
+            return
+
+        existing.status = "done"
+        existing.detail = _merge_detail(existing.detail, event.text or "(ok)")
+
+    def _append_row(self, *, kind: str, label: str, status: str, detail: str) -> TraceRow:
+        row = TraceRow(
+            step=self._next_step,
+            kind=kind,
+            label=label,
+            status=status,
+            detail=detail,
+        )
+        self._next_step += 1
+        self.rows.append(row)
+        self._trim_rows()
+        return row
+
+    def _trim_rows(self) -> None:
+        while len(self.rows) > self.max_rows:
+            dropped = self.rows.pop(0)
+            stale_keys = [key for key, value in self._active_tools.items() if value is dropped]
+            for key in stale_keys:
+                self._active_tools.pop(key, None)
+            stale_subagents = [key for key, value in self._active_subagents.items() if value is dropped]
+            for key in stale_subagents:
+                self._active_subagents.pop(key, None)
+
+
+class OrchestrationLedger:
+    def __init__(self) -> None:
+        self.rows: list[OrchestrationRow] = []
+        self._rows_by_name: dict[str, OrchestrationRow] = {}
+        self._active_runs: dict[str, OrchestrationRow] = {}
+
+    def configure(self, subagents: list[dict[str, str]]) -> None:
+        self.rows.clear()
+        self._rows_by_name.clear()
+        self._active_runs.clear()
+        if not subagents:
+            self.rows.append(
+                OrchestrationRow(
+                    name="-",
+                    role="No configured subagents",
+                    tools="-",
+                    status="idle",
+                    detail="This agent currently runs without delegated subagent roles.",
+                )
+            )
+            return
+        for subagent in subagents:
+            row = OrchestrationRow(
+                name=subagent["name"],
+                role=subagent["role"],
+                tools=subagent["tools"],
+                status="idle",
+                detail=subagent.get("detail", "Ready"),
+            )
+            self.rows.append(row)
+            self._rows_by_name[row.name] = row
+
+    def record(self, event: StreamEvent) -> None:
+        if event.kind != "subagent":
+            return
+        run_key = event.trace_id or event.label
+        if event.phase == "start":
+            row = self._rows_by_name.get(event.label)
+            if row is None:
+                if self.rows and self.rows[0].name == "-":
+                    self.rows.clear()
+                row = OrchestrationRow(
+                    name=event.label,
+                    role="Delegated task",
+                    tools="dynamic",
+                    status="idle",
+                    detail="Discovered from runtime activity.",
+                )
+                self.rows.append(row)
+                self._rows_by_name[row.name] = row
+            row.status = "running"
+            row.detail = event.text or "delegated"
+            if event.trace_id:
+                self._active_runs[run_key] = row
+            return
+
+        row = self._active_runs.pop(run_key, None)
+        if row is None:
+            row = self._rows_by_name.get(event.label)
+        if row is None:
+            row = OrchestrationRow(
+                name=event.label,
+                role="Delegated task",
+                tools="dynamic",
+                status="done",
+                detail=event.text or "(ok)",
+            )
+            self.rows.append(row)
+            self._rows_by_name[row.name] = row
+            return
+        row.status = "done"
+        row.detail = _merge_detail(row.detail, event.text or "(ok)")
+
+    def record_status(self, name: str, status: str, detail: str) -> None:
+        row = self._rows_by_name.get(name)
+        if row is None:
+            return
+        row.status = status
+        row.detail = detail
+
+
+class TraceTable(DataTable[str]):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.ledger = TraceLedger()
+        self.cursor_type = "none"
+        self.zebra_stripes = True
+        self._configured = False
+
+    def on_mount(self) -> None:
+        self._ensure_columns()
+
+    def begin_run(self, agent_name: str, thread_id: str) -> None:
+        self.ledger.begin_run(agent_name, thread_id)
+        self._render_rows()
+
+    def reset(self) -> None:
+        self.ledger.reset()
+        self._render_rows()
+
+    def record_event(self, event: StreamEvent) -> None:
+        self.ledger.record(event)
+        self._render_rows()
+
+    def record_status(self, *, label: str, status: str, detail: str, kind: str = "state") -> None:
+        self.ledger.add_status(label=label, status=status, detail=detail, kind=kind)
+        self._render_rows()
+
+    def _ensure_columns(self) -> None:
+        if self._configured:
+            return
+        self.show_row_labels = False
+        self.add_column("Step", key="step", width=6)
+        self.add_column("Kind", key="kind", width=10)
+        self.add_column("Target", key="label", width=18)
+        self.add_column("Status", key="status", width=10)
+        self.add_column("Detail", key="detail")
+        self._configured = True
+
+    def _render_rows(self) -> None:
+        self._ensure_columns()
+        self.clear(columns=False)
+        for row in self.ledger.rows:
+            self.add_row(
+                str(row.step),
+                row.kind,
+                row.label,
+                row.status,
+                row.detail,
+                key=f"trace-{row.step}",
+            )
+
+
+class OrchestrationTable(DataTable[str]):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.ledger = OrchestrationLedger()
+        self.cursor_type = "none"
+        self.zebra_stripes = True
+        self._configured = False
+
+    def on_mount(self) -> None:
+        self._ensure_columns()
+
+    def configure_subagents(self, subagents: list[dict[str, str]]) -> None:
+        self.ledger.configure(subagents)
+        self._render_rows()
+
+    def reset(self) -> None:
+        self.ledger.configure([])
+        self._render_rows()
+
+    def record_event(self, event: StreamEvent) -> None:
+        self.ledger.record(event)
+        self._render_rows()
+
+    def record_status(self, name: str, status: str, detail: str) -> None:
+        self.ledger.record_status(name, status, detail)
+        self._render_rows()
+
+    def _ensure_columns(self) -> None:
+        if self._configured:
+            return
+        self.show_row_labels = False
+        self.add_column("Subagent", key="name", width=20)
+        self.add_column("Role", key="role", width=30)
+        self.add_column("Tools", key="tools", width=18)
+        self.add_column("Status", key="status", width=10)
+        self.add_column("Detail", key="detail")
+        self._configured = True
+
+    def _render_rows(self) -> None:
+        self._ensure_columns()
+        self.clear(columns=False)
+        for index, row in enumerate(self.ledger.rows, start=1):
+            self.add_row(
+                row.name,
+                row.role,
+                row.tools,
+                row.status,
+                row.detail,
+                key=f"orchestration-{index}",
+            )
+
+
+def _merge_detail(current: str, new: str) -> str:
+    normalized_current = current.strip()
+    normalized_new = new.strip()
+    if not normalized_current:
+        return normalized_new
+    if not normalized_new or normalized_current == normalized_new:
+        return normalized_current
+    return f"{normalized_current} -> {normalized_new}"

agencli/tui/voice.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import sys
+from textwrap import dedent
+
+
+VOICE_TIMEOUT_SECONDS = 15
+
+
+def _powershell_executable() -> str:
+    return "powershell.exe" if sys.platform == "win32" else "pwsh"
+
+
+def _encode_powershell(script: str) -> str:
+    return base64.b64encode(script.encode("utf-16-le")).decode("ascii")
+
+
+def build_voice_capture_script(timeout_seconds: int = VOICE_TIMEOUT_SECONDS) -> str:
+    timeout_seconds = max(3, int(timeout_seconds))
+    return dedent(
+        f"""
+        $ErrorActionPreference = 'Stop'
+        [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+        Add-Type -AssemblyName System.Speech
+
+        $culture = [System.Globalization.CultureInfo]::InstalledUICulture
+        try {{
+            $engine = New-Object System.Speech.Recognition.SpeechRecognitionEngine($culture)
+        }} catch {{
+            $engine = New-Object System.Speech.Recognition.SpeechRecognitionEngine('en-US')
+        }}
+
+        $engine.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar))
+        $engine.SetInputToDefaultAudioDevice()
+        $result = $engine.Recognize([TimeSpan]::FromSeconds({timeout_seconds}))
+
+        if ($null -eq $result -or [string]::IsNullOrWhiteSpace($result.Text)) {{
+            exit 0
+        }}
+
+        Write-Output $result.Text
+        """
+    ).strip()
+
+
+async def transcribe_once(timeout_seconds: int = VOICE_TIMEOUT_SECONDS) -> str:
+    script = build_voice_capture_script(timeout_seconds=timeout_seconds)
+    encoded = _encode_powershell(script)
+    process = await asyncio.create_subprocess_exec(
+        _powershell_executable(),
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        encoded,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout, stderr = await process.communicate()
+    except asyncio.CancelledError:
+        if process.returncode is None:
+            process.terminate()
+            try:
+                await asyncio.wait_for(process.wait(), timeout=1.0)
+            except asyncio.TimeoutError:
+                process.kill()
+                await process.wait()
+        raise
+
+    if process.returncode not in (0, None):
+        error_text = (stderr or b"").decode("utf-8", errors="replace").strip()
+        raise RuntimeError(error_text or "Voice capture failed.")
+
+    return (stdout or b"").decode("utf-8", errors="replace").strip()

agencode-0.1.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: agencode
+Version: 0.1.0
+Summary: AgenCLI: a multi-agent terminal workspace built in Python.
+Requires-Python: >=3.12
+Requires-Dist: deepagents
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: langchain
+Requires-Dist: langchain-mcp-adapters
+Requires-Dist: langchain-openai
+Requires-Dist: langgraph
+Requires-Dist: langgraph-checkpoint-sqlite
+Requires-Dist: rich>=14.1.0
+Requires-Dist: textual>=6.2.1
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: typer>=0.19.2
+Description-Content-Type: text/markdown
+
+# AgenCLI
+
+AgenCLI is the Python reboot of the original agent CLI concept: a multi-agent terminal workspace with a Textual UI and a DeepAgents/LangGraph runtime.
+
+This repo is now scaffolded as a proper `uv` project with:
+
+- a package entrypoint at `agencode`
+- `agencode tui` uses the current directory as the workspace by default
+- a Typer CLI
+- a minimal Textual app
+- config and session directory bootstrapping
+- basic agent registry and runtime stubs for the later DeepAgents integration
+- CLI support for OpenAI-compatible `base_url`, `api_key`, `model`, and `model_kind`
+
+## Run
+
+```bash
+uv sync
+uv run agencode doctor
+uv run agencode config-openai --base-url https://api.deepseek.com --model deepseek-chat --model-kind chat
+uv run agencode tui
+
+# Open a specific workspace explicitly
+uv run agencode tui --workspace /path/to/project
+```

agencode-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+agencli/__init__.py,sha256=aIM0xbT8C85KKpWTJs7xEIEVhvfpLw0UCVqAm1Yyp1M,73
+agencli/__main__.py,sha256=5zufvIUIZc3u_eknnGzLgjcf9_K1AKpfOnz_js_qlm8,100
+agencli/cli.py,sha256=jAqFC40LmBbxXwb_WxrSJ3xhUITJTuprQeOus80E2oc,22733
+agencli/agents/__init__.py,sha256=592-nFGEczCezV9HOuOHFy6v6xb3-F_e6HyNDaITLtU,51
+agencli/agents/editor.py,sha256=2rYdef0Akvty5dxziujBbzNizedp2PMh_b6SWRPVEqE,3531
+agencli/agents/factory.py,sha256=N__E4pHcjV9Qr4xH3Ot1unogRCgsTnccRSqiOcAJhZs,12404
+agencli/agents/management_tools.py,sha256=IY-RwiWrm8pBFrUY01TCM6CrEmgsqWdclY4LuT9xw4k,10911
+agencli/agents/registry.py,sha256=TsudkVwch6p5PcBURy7u7YBk3Svxie5DXCmbq86NyPc,1875
+agencli/agents/runtime.py,sha256=uGSjxG-F6GMHfDHT-LfkgDe0H9VTTLzKyMk1eUpcbLI,8672
+agencli/agents/supervisor.py,sha256=uhS3o_mdpePPe-tSfLYXdU_6N2cZSqdlw_LHr7vjUuw,4105
+agencli/agents/prebuilt/__init__.py,sha256=shljfx-NVNf1JTVzdzyL-9hFrHrck8aquRSSwND5Tu8,34
+agencli/agents/prebuilt/catalog.py,sha256=RMPKS0ZbKJxPwUC5gqtuieuDayi6aaxQgm-FTzVY4PA,3323
+agencli/core/__init__.py,sha256=FbCxjjAZmG--aZIGwWuHZ3bBXlgZnhK_2Aalkzw6AAk,43
+agencli/core/config.py,sha256=FCQD0R9yc2xHvBpp6YzLWaDGV8Qq1ALq3oXp5JAN6tY,6468
+agencli/core/keystore.py,sha256=Rutx-vT-Z2V0yGZbSoxl9CjATes6TqkTcupOJzzKCv8,329
+agencli/core/logger.py,sha256=tYLBtMn_ejZoHng2vzqZ1YtFFc4zvEWrQkiL4Ku5CNs,445
+agencli/core/paths.py,sha256=QFxRBMFFLtohyPkdorhKjfA4w67Ukz4PRlX066sXrro,1044
+agencli/core/session.py,sha256=fcycfQL9IT6UPT1GLfGrEaCGuLIC_WiaYjZOoCFdD38,16608
+agencli/mcp/__init__.py,sha256=AdBHnJvMClCg8rLH5aby2v9W4ykVr5hKAadxpHfAY9o,44
+agencli/mcp/client.py,sha256=mEqJfH7EGpbH8KYrYOd9MyDDFFXpS8PZwX5GtiDlGkQ,1186
+agencli/mcp/config.py,sha256=SdT27hM_PJxaJ1oXh5T1k0KuRF3j6Tr-Ah78bGAjwiI,3252
+agencli/providers/__init__.py,sha256=fPCpETqrBU6cejso3j_BKhH9_yYvPe3VfvPy1rRzCZk,32
+agencli/providers/model.py,sha256=qlXB6HEOFEVPavoQsNNe_Q1oJq0dOjzlk6AbyneF9DY,6425
+agencli/skills/__init__.py,sha256=Zfw_2JkkJo09jduwTh4y4SRRUsIU-LmkwNLkGVl9l_Y,952
+agencli/skills/cli_backend.py,sha256=ApY7c2OypCMgDshmM66taW1X3xAopj6mQpy7WQOD8Jg,16166
+agencli/skills/loader.py,sha256=BRhDNcPz93fFktyCe7pocmsqqWfpJBMhcN0QK6I5Cvc,2475
+agencli/skills/manager.py,sha256=637GY1N4W6B2qOUm1TZW1XPgMZeYut2SSKn0z44TCtw,5701
+agencli/tools/__init__.py,sha256=mVLTc6KR5PZ931StQuAf8ESGOnakszxFpYRSWgKlnv8,59
+agencli/tools/mcp.py,sha256=jidkNX3IafHr60VXqzqrM_yDzbQwtSFpmPc65YJIaUI,3943
+agencli/tui/__init__.py,sha256=tjeCtfeMyy9I0mVxRRbpi83cYVJ-p65lwJOGDyVWcMg,30
+agencli/tui/app.py,sha256=IBHjBOYlqNoXjpRvqVzj0Ft3rX9BrWsMfEim5eBHAfs,181478
+agencli/tui/commands.py,sha256=7rmbwkRSv1MFmW9iu5zHK849vv1RU9QQVkKMaBOlVk4,4485
+agencli/tui/screens.py,sha256=RzBO0a4OcgszlQ2rY1T8qpV3uV79A4rVYkpHOwXChDo,35291
+agencli/tui/trace.py,sha256=U3o1bMIMg_983SKv9kgirW6ybWezLu19l7k00v_aCKo,10806
+agencli/tui/voice.py,sha256=I9wqQLw-og8dcK__lGd9Mc-wADIuIJ0tSSu1Sqb59Fg,2485
+agencode-0.1.0.dist-info/METADATA,sha256=hOmP6T0VIsFMOgsuVq2afALphJ9jlFyIQEgmVNjh2Ys,1396
+agencode-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agencode-0.1.0.dist-info/entry_points.txt,sha256=WgOWlIZAEhNazwvFucLq_R3jlo9dFx4yQBBnJP7GLRo,83
+agencode-0.1.0.dist-info/RECORD,,

agencode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agencode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agencli = agencli.__main__:main
+agencode = agencli.__main__:main