aisha 0.2.2__py3-none-any.whl

aisha/__init__.py

@@ -0,0 +1,4 @@
+# Author: Tischenko A. (https://github.com/cruide)
+"""aisha — local console AI agent working with an external llama-server."""
+
+__version__ = "0.2.2"

aisha/__main__.py

@@ -0,0 +1,5 @@
+# Author: Tischenko A. (https://github.com/cruide)
+from aisha.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aisha/agent.py

@@ -0,0 +1,244 @@
+# Author: Tischenko A. (https://github.com/cruide)
+"""AgentLoop: model -> tool calls -> tool results -> model, with limits and compaction."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Protocol
+
+from aisha.client import ChatResponse, LlamaClient, ToolCall
+from aisha.config import Config
+from aisha.context import ConversationContext
+from aisha.errors import AishaError
+from aisha.tools.base import ToolContext, ToolRegistry, ToolResult
+
+# Read-only tools without side effects: consecutive calls run concurrently.
+PARALLEL_TOOLS = frozenset({
+    "read_file", "list_dir", "glob", "grep", "web_search", "web_fetch", "memory_get", "memory_list",
+})
+
+SUMMARY_SYSTEM = (
+    "Ты сжимаешь историю диалога AI-агента для программиста. Составь структурированную сводку "
+    "на русском: 1) цель пользователя; 2) что уже сделано (файлы, команды, результаты); "
+    "3) важные факты и решения; 4) незавершённые задачи и следующие шаги. Без воды, без "
+    "инструментов, только текст."
+)
+SUMMARY_REQUEST = "Сделай сводку диалога выше по указанной структуре."
+
+
+class AgentEvents(Protocol):
+    def on_stream_start(self) -> None: ...
+    def on_text(self, delta: str) -> None: ...
+    def on_reasoning(self, delta: str) -> None: ...
+    def on_stream_end(self, response: ChatResponse) -> None: ...
+    def on_tool_start(self, call: ToolCall, args: dict[str, Any] | None) -> None: ...
+    def on_tool_end(self, call: ToolCall, result: ToolResult) -> None: ...
+    def on_notice(self, text: str, level: str = "info") -> None: ...
+    def on_debug(self, title: str, body: str) -> None: ...
+
+
+class AgentLoop:
+    def __init__(
+        self,
+        config: Config,
+        client: LlamaClient,
+        registry: ToolRegistry,
+        context: ConversationContext,
+        tool_ctx: ToolContext,
+        events: AgentEvents,
+    ) -> None:
+        self.config = config
+        self.client = client
+        self.registry = registry
+        self.context = context
+        self.tool_ctx = tool_ctx
+        self.events = events
+
+    # ------------------------------------------------------------------ turn
+    async def run(self, user_text: str) -> str:
+        self.context.add_user(user_text)
+        try:
+            return await self._run_turn()
+        except BaseException:
+            # Keep history valid if we were interrupted between tool_calls and results.
+            self.context.close_dangling_tool_calls("Операция прервана пользователем.")
+            raise
+
+    async def _run_turn(self) -> str:
+        llm = self.config.llm
+        iterations = 0
+        limit_hit = False
+        skip_compact = False
+        while True:
+            if not skip_compact and self.context.needs_compaction():
+                await self.compact()
+                if self.context.needs_compaction():
+                    skip_compact = True
+                    self.events.on_notice(
+                        "Сжатие не освободило достаточно контекста; "
+                        "продолжаю без повторной попытки.",
+                        "warn",
+                    )
+            tools = None if limit_hit else self.registry.schemas(read_only=self.config.read_only)
+            response = await self._call_model(tools)
+            self.context.add_assistant(response)
+            if response.finish_reason == "length":
+                self.events.on_notice("Ответ обрезан: достигнут лимит max_output_tokens.", "warn")
+            if not response.tool_calls:
+                return response.content
+            if limit_hit:
+                self._refuse_calls(response.tool_calls, "Инструменты недоступны: лимит исчерпан.")
+                return response.content
+            iterations += 1
+            if iterations > llm.max_tool_iterations:
+                self.events.on_notice(
+                    f"Достигнут лимит итераций инструментов ({llm.max_tool_iterations}); "
+                    "запрашиваю итоговый ответ.", "warn",
+                )
+                self._refuse_calls(
+                    response.tool_calls,
+                    "Лимит итераций инструментов исчерпан. Сформируй итоговый ответ для "
+                    "пользователя без новых вызовов инструментов.",
+                )
+                limit_hit = True
+                continue
+            await self._execute_calls(response.tool_calls)
+            skip_compact = False
+
+    def _refuse_calls(self, calls: list[ToolCall], message: str) -> None:
+        for call in calls:
+            result = ToolResult.failure("IterationLimit", message)
+            self.context.add_tool_result(call.id, call.name, result.to_json())
+
+    async def _call_model(self, tools: list[dict[str, Any]] | None) -> ChatResponse:
+        llm = self.config.llm
+        messages = self.context.all_messages()
+        chars_in = self.context.sent_chars()
+        est_in = self.context.estimate_sent_tokens()
+        sampling = {
+            key: value for key, value in (
+                ("top_p", llm.top_p),
+                ("top_k", llm.top_k),
+                ("repeat_penalty", llm.repeat_penalty),
+                ("frequency_penalty", llm.frequency_penalty),
+            ) if value is not None
+        }
+        remaining = llm.context_window - est_in
+        max_tokens = max(256, min(llm.max_output_tokens, remaining))
+        if self.config.ui.debug:
+            self.events.on_debug("→ model", self._format_request(messages, est_in))
+        self.events.on_stream_start()
+        response = await self.client.chat(
+            messages, tools, temperature=llm.temperature,
+            max_tokens=max_tokens, on_event=self._on_event,
+            sampling=sampling or None,
+        )
+        produced = response.content + response.reasoning + "".join(
+            c.arguments for c in response.tool_calls
+        )
+        self.context.stats.record(response.usage, est_in, self.context.estimate_text(produced),
+                                  chars_in)
+        self.events.on_stream_end(response)
+        if self.config.ui.debug:
+            self.events.on_debug("← model", self._format_response(response))
+        return response
+
+    def _on_event(self, kind: str, delta: str) -> None:
+        if kind == "text":
+            self.events.on_text(delta)
+        elif kind == "reasoning":
+            self.events.on_reasoning(delta)
+
+    @staticmethod
+    def _clip(text: str, limit: int) -> str:
+        text = text.strip()
+        return text if len(text) <= limit else text[:limit] + "…"
+
+    def _format_request(self, messages: list[dict[str, Any]], est_tokens: int) -> str:
+        lines = [f"сообщений: {len(messages)}, ~{est_tokens} токенов"]
+        for m in messages:
+            role = m.get("role")
+            if m.get("tool_calls"):
+                names = [c.get("function", {}).get("name", "?") for c in m["tool_calls"]]
+                lines.append(f"  {role}: [tool_calls] {', '.join(names)}")
+                continue
+            content = m.get("content")
+            body = content if isinstance(content, str) else json.dumps(content,
+                                                                       ensure_ascii=False)
+            lines.append(f"  {role}: {self._clip(body, 240)}")
+        return "\n".join(lines)
+
+    def _format_response(self, response: ChatResponse) -> str:
+        parts: list[str] = []
+        if response.reasoning:
+            parts.append(f"reasoning: {self._clip(response.reasoning, 600)}")
+        if response.content:
+            parts.append(f"content: {self._clip(response.content, 600)}")
+        for c in response.tool_calls:
+            parts.append(f"tool_call: {c.name}({self._clip(c.arguments, 300)})")
+        if response.finish_reason:
+            parts.append(f"finish_reason: {response.finish_reason}")
+        if response.usage:
+            parts.append(f"usage: {response.usage}")
+        return "\n".join(parts) or "(пусто)"
+
+    # ----------------------------------------------------------------- tools
+    async def _execute_calls(self, calls: list[ToolCall]) -> None:
+        i = 0
+        while i < len(calls):
+            if calls[i].name in PARALLEL_TOOLS:
+                j = i
+                while j < len(calls) and calls[j].name in PARALLEL_TOOLS:
+                    j += 1
+                await asyncio.gather(*(self._run_call(c) for c in calls[i:j]))
+                i = j
+            else:
+                await self._run_call(calls[i])
+                i += 1
+
+    async def _run_call(self, call: ToolCall) -> None:
+        tool = self.registry.get(call.name)
+        silent = bool(tool and tool.silent)
+        try:
+            args = call.parse_arguments()
+        except ValueError as exc:
+            if not silent:
+                self.events.on_tool_start(call, None)
+            result = ToolResult.failure("ToolValidationError",
+                                        f"Некорректный JSON аргументов: {exc}")
+        else:
+            if not silent:
+                self.events.on_tool_start(call, args)
+            result = await self.registry.execute(call.name, args, self.tool_ctx)
+        if not silent:
+            self.events.on_tool_end(call, result)
+        self.context.add_tool_result(call.id, call.name, result.to_json())
+        if self.config.ui.debug and not silent:
+            self.events.on_debug(f"tool: {call.name}", self._clip(result.to_json(), 2000))
+
+    # ------------------------------------------------------------ compaction
+    async def compact(self, *, force: bool = False) -> bool:
+        blocks = self.context.turn_blocks()
+        if len(blocks) < 2:
+            if force:
+                self.events.on_notice("История слишком короткая, сжимать нечего.")
+            return False
+        old = [m for block in blocks[:-1] for m in block]
+        keep = blocks[-1]
+        self.events.on_notice("Сжимаю историю диалога…")
+        summary: str | None = None
+        try:
+            response = await self.client.chat(
+                [{"role": "system", "content": SUMMARY_SYSTEM}, *old,
+                 {"role": "user", "content": SUMMARY_REQUEST}],
+                None, temperature=0.1, max_tokens=2048,
+            )
+            summary = response.content.strip() or None
+        except AishaError as exc:
+            self.events.on_notice(f"Сводка не удалась ({exc}); старые сообщения удалены.", "warn")
+        self.context.replace_history(summary, keep)
+        self.events.on_notice(
+            f"История сжата: {len(old)} сообщений → {'сводка' if summary else 'удалены'}."
+        )
+        return True

aisha/cli.py

@@ -0,0 +1,236 @@
+# Author: Tischenko A. (https://github.com/cruide)
+"""Entry point: argument parsing, wiring, --doctor, one-shot and REPL modes."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from aisha import __version__
+from aisha.agent import AgentLoop
+from aisha.client import LlamaClient
+from aisha.config import Config, load_config
+from aisha.context import ConversationContext, build_tool_guide
+from aisha.errors import AishaError, ConfigurationError
+from aisha.memory import MemoryStore
+from aisha.skills import SkillIndex
+from aisha.tools.base import ToolContext, ToolRegistry
+from aisha.tools.extras import (
+    AskUserTool,
+    MemoryGetTool,
+    MemoryListTool,
+    MemoryReplaceTool,
+    MemorySetTool,
+    SkillTool,
+    TodoWriteTool,
+)
+from aisha.tools.files import (
+    EditFileTool,
+    GlobTool,
+    GrepTool,
+    ListDirTool,
+    ReadFileTool,
+    WriteFileTool,
+)
+from aisha.tools.shell import RunCommandTool
+from aisha.tools.web import WebFetchTool, WebSearchTool
+from aisha.ui import ConsoleUI
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="aisha", description="Локальный консольный AI-агент.")
+    p.add_argument("prompt", nargs="*", help="одноразовый запрос (без него — REPL)")
+    p.add_argument("--server", help="URL llama-server, например http://localhost:8088")
+    p.add_argument("--model", help="имя модели (alias -a на сервере)")
+    p.add_argument("--api-key", help="API-ключ для сервера (если требуется авторизация)")
+    p.add_argument("-r", "--read-only", action="store_true", help="режим только для чтения")
+    p.add_argument("--permission", choices=("auto", "ask", "deny"), help="режим shell")
+    p.add_argument("--shell", choices=("powershell", "cmd"), help="оболочка по умолчанию")
+    p.add_argument("--tools-only", action="store_true", help="показать инструменты и выйти")
+    p.add_argument("--doctor", action="store_true", help="диагностика подключения")
+    p.add_argument("--tool-call-test", action="store_true",
+                   help="с --doctor: проверить tool calling")
+    p.add_argument("--no-color", action="store_true", help="отключить цвета")
+    p.add_argument("--debug", action="store_true",
+                   help="режим отладки: reasoning модели, дампы запросов/ответов, traceback")
+    p.add_argument("--version", action="version", version=f"aisha {__version__}")
+    return p
+
+
+def cli_overrides(args: argparse.Namespace) -> dict[str, dict[str, Any]]:
+    over: dict[str, dict[str, Any]] = {}
+    if args.server:
+        over.setdefault("server", {})["base_url"] = args.server
+    if args.model:
+        over.setdefault("server", {})["model"] = args.model
+    if args.api_key:
+        over.setdefault("server", {})["api_key"] = args.api_key
+    if args.permission:
+        over.setdefault("tools", {})["permission"] = args.permission
+    if args.shell:
+        over.setdefault("tools", {})["shell_type"] = args.shell
+    if args.debug:
+        over.setdefault("ui", {})["debug"] = True
+    return over
+
+
+def build_registry(config: Config) -> ToolRegistry:
+    registry = ToolRegistry()
+    for tool in (ReadFileTool(), WriteFileTool(), EditFileTool(), ListDirTool(), GlobTool(),
+                 GrepTool()):
+        registry.register(tool)
+    if config.tools.shell:
+        registry.register(RunCommandTool())
+    if config.tools.web_search:
+        registry.register(WebSearchTool())
+    registry.register(WebFetchTool())
+    registry.register(TodoWriteTool())
+    registry.register(AskUserTool())
+    registry.register(SkillTool())
+    if config.memory.enabled:
+        for tool in (MemoryListTool(), MemoryGetTool(), MemorySetTool(), MemoryReplaceTool()):
+            registry.register(tool)
+    return registry
+
+
+async def run_doctor(config: Config, client: LlamaClient, ui: ConsoleUI,
+                     tool_call_test: bool = False) -> bool:
+    ok_all = True
+
+    def report(ok: bool, label: str, detail: str = "", warn: bool = False) -> None:
+        nonlocal ok_all
+        if not ok and not warn:
+            ok_all = False
+        mark = "[green]✓[/]" if ok else ("[yellow]⚠[/]" if warn else "[red]✗[/]")
+        ui.console.print(f"  {mark} {label}" + (f" [dim]— {detail}[/]" if detail else ""))
+
+    ui.console.print(f"[bold]Диагностика[/] {config.server.base_url}")
+    try:
+        health = await client.health()
+        report(True, "/health", str(health.get("status", "ok")))
+    except AishaError as exc:
+        report(False, "/health", str(exc))
+        ui.info("Проверьте, что llama-server запущен (команда — в README.md).")
+        return False
+    try:
+        info = await client.model_info()
+        names = list(info)
+        report(bool(names), "/v1/models", ", ".join(names) or "пусто")
+        if not names:
+            return False
+        if client.model in info:
+            model, matched = client.model, True
+        else:
+            model, matched = names[0], False
+            client.model = model
+        report(matched, "модель", model if matched else
+               f"'{config.server.model}' не найдена, используется '{model}'", warn=True)
+    except AishaError as exc:
+        report(False, "/v1/models", str(exc))
+        return False
+    try:
+        resp = await client.chat([{"role": "user", "content": "Ответь одним словом: ok"}],
+                                 None, temperature=0.0, max_tokens=64)
+        report(bool(resp.content.strip()), "/v1/chat/completions",
+               f"ответ: {resp.content.strip()[:40]!r}, usage: {'есть' if resp.usage else 'нет'}")
+    except AishaError as exc:
+        report(False, "/v1/chat/completions", str(exc))
+    if tool_call_test:
+        echo = {"type": "function", "function": {
+            "name": "echo", "description": "Вернуть переданный текст без изменений",
+            "parameters": {"type": "object", "properties": {"text": {"type": "string"}},
+                           "required": ["text"]}}}
+        try:
+            resp = await client.chat(
+                [{"role": "user", "content": "Вызови инструмент echo с текстом 'ping'."}],
+                [echo], temperature=0.0, max_tokens=1024,
+            )
+            calls = [f"{c.name}({c.arguments})" for c in resp.tool_calls]
+            report(any(c.name == "echo" for c in resp.tool_calls), "tool calling",
+                   ", ".join(calls) or f"инструмент не вызван: {resp.content[:60]!r}")
+        except AishaError as exc:
+            report(False, "tool calling", str(exc))
+    ui.console.print("[green]Готово: всё в порядке.[/]" if ok_all else
+                     "[red]Обнаружены проблемы.[/]")
+    return ok_all
+
+
+async def _amain(args: argparse.Namespace) -> int:
+    workspace = Path.cwd().resolve()
+    no_color = args.no_color or bool(os.environ.get("NO_COLOR"))
+    ui = ConsoleUI(no_color=no_color, debug=args.debug)
+    try:
+        config = load_config(workspace, cli=cli_overrides(args), read_only=args.read_only)
+    except ConfigurationError as exc:
+        ui.error(f"Ошибка конфигурации: {exc}")
+        return 2
+
+    registry = build_registry(config)
+    if args.tools_only:
+        ui.print_tools(registry)
+        return 0
+
+    client = LlamaClient(config.server.base_url, config.server.model,
+                         api_key=config.server.api_key,
+                         connect_timeout=config.server.connect_timeout,
+                         request_timeout=config.server.request_timeout)
+    try:
+        if args.doctor:
+            return 0 if await run_doctor(config, client, ui, args.tool_call_test) else 1
+        try:
+            model, matched, n_ctx = await client.resolve_model_meta()
+        except AishaError as exc:
+            ui.error(str(exc), exc)
+            ui.info("Подсказка: aisha --doctor покажет подробности; сервер должен слушать "
+                    f"{config.server.base_url}.")
+            return 1
+
+        # if not matched:
+        #     ui.warn(f"Модель '{config.server.model}' не найдена на сервере, "
+        #             f"используется '{model}'.")
+
+        if n_ctx:
+            config.llm.context_window = n_ctx
+            config.llm.max_output_tokens = n_ctx
+
+        memory = (MemoryStore(config.home_dir / "memory", config.project_dir / "memory",
+                              max_block_chars=config.memory.max_block_chars)
+                  if config.memory.enabled else None)
+        skills = SkillIndex(config.home_dir / "skills", config.project_dir / "skills")
+        tool_guide = (build_tool_guide(registry.schemas(read_only=config.read_only))
+                      if config.llm.tool_guide else "")
+        context = ConversationContext(config, memory, skills, tool_guide)
+        ui.attach(config, context, client)
+        tool_ctx = ToolContext(
+            workspace=workspace, config=config, memory=memory, skills=skills,
+            todos=context.todos, confirm=ui.confirm if ui.interactive else None,
+            ask=ui.ask_user if ui.interactive else None, interactive=ui.interactive,
+            on_system_change=context.invalidate,
+        )
+        agent = AgentLoop(config, client, registry, context, tool_ctx, ui)
+
+        prompt = " ".join(args.prompt).strip()
+        if prompt:
+            return await ui.run_once(agent, prompt)
+        await ui.run_repl(agent, registry, lambda: run_doctor(config, client, ui))
+        return 0
+    finally:
+        await client.close()
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if os.name == "nt":
+        for stream in (sys.stdout, sys.stderr):
+            try:
+                stream.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
+            except (AttributeError, ValueError):
+                pass
+    try:
+        return asyncio.run(_amain(args))
+    except KeyboardInterrupt:
+        return 130