dostuff 0.1.0__py3-none-any.whl

dostuff/__init__.py

@@ -0,0 +1,2 @@
+# Package init — lazy, doesn't pull agent loop on import
+__version__ = "1.0.0"

dostuff/agent/call_agent.py

@@ -0,0 +1,44 @@
+from dostuff.lib.tracing import traced
+from opentelemetry import trace as otel_trace
+from dostuff.tools.definitions import TOOL_SCHEMAS
+from litellm import acompletion
+from dostuff.lib.model import MODEL
+
+@traced("model_call")
+async def call_agent(steps_history: list, system_instruction: str, tool_names: list[str] | None = None):
+    if tool_names is None:
+        tool_names = list(TOOL_SCHEMAS.keys())
+
+    active_schemas = [
+        TOOL_SCHEMAS[name]
+        for name in tool_names
+        if name in TOOL_SCHEMAS
+    ]
+
+    messages = [{"role": "system", "content": system_instruction}] + steps_history    
+
+    async def _make_request():
+        return await acompletion(
+            model=MODEL,
+            messages=messages,
+            tools=active_schemas,
+            drop_invalid_params=True 
+        )
+
+    try:
+        interaction = await _make_request()
+    except Exception as e:
+        if "malformed_tool_call" not in str(e):
+            raise
+        from dostuff.helpers.ui.emit import emit
+        emit("Model returned malformed JSON — retrying once...", msg_type="system")
+        interaction = await _make_request()
+
+    usage = getattr(interaction, "usage", None)
+    if usage is not None:
+        span = otel_trace.get_current_span()
+        span.set_attribute("usage.total_tokens", getattr(usage, "total_tokens", 0))
+        span.set_attribute("usage.input_tokens", getattr(usage, "prompt_tokens", 0))
+        span.set_attribute("usage.output_tokens", getattr(usage, "completion_tokens", 0))
+
+    return interaction

dostuff/agent/loop.py

@@ -0,0 +1,161 @@
+from dostuff.helpers.agent.get_model_token_limit import get_model_token_limit
+from dostuff.lib.exceptions import ConfirmationRequired
+from dostuff.lib.mcp.mcp_client import MCPClient
+from dostuff.lib.memory.session_store import SessionStore
+from dostuff.lib.tracing import tracer
+from dostuff.helpers.agent.constants import MAX_ITERATIONS
+from dostuff.helpers.agent.manage_context import compact_context
+from typing import Literal, Optional, Any
+from dostuff.agent.call_agent import call_agent
+from opentelemetry.trace import Status, StatusCode
+from dostuff.helpers.agent.append_step import append_step
+import asyncio
+from dostuff.agent.run_tool import run_tool
+import json
+
+async def loop(session_id: str, turn_id: str, user_text: str, dynamic_system_instruction: str, mcp_client: MCPClient,  working_history: list,   turn_type: Literal['interactive_loop', 'learning_loop', 'subagent_loop'], current_session_history: list = [], steps_history: list = [],  store: SessionStore | None = None, adapter: Optional[Any] = None) -> str:
+
+    async def _emit(et, data):
+        if adapter and hasattr(adapter, "emit"):
+            try:
+                adapter.emit(et, data)
+            except Exception:
+                pass
+
+    iteration = 0
+    last_input_tokens = 0
+    token_limit = get_model_token_limit()
+    context_token_threshold = int(token_limit * 0.5)
+    keep_recent_token_budget = int(context_token_threshold * 0.15)
+    compaction_notes = ""
+
+    with tracer.start_as_current_span("turn") as turn_span:
+        turn_span.set_attribute("session_id", session_id)
+        turn_span.set_attribute("turn_type", turn_type)
+        turn_span.set_attribute("turn_id", turn_id)
+        turn_span.set_attribute("user_input", user_text)
+        while iteration < MAX_ITERATIONS:
+            iteration += 1
+            with tracer.start_as_current_span("iteration") as iter_span:
+                iter_span.set_attribute("iteration_number", iteration)
+
+                # context compaction
+                if last_input_tokens > context_token_threshold:
+                    working_history, new_summary = await compact_context(working_history, keep_recent_token_budget)
+                    compaction_notes = f"{compaction_notes}\n{new_summary}".strip()
+                    with tracer.start_as_current_span("context_compaction") as compaction_span:
+                        compaction_span.set_attribute("steps_after", len(working_history))
+                
+                # agent call  
+                interaction = await call_agent(steps_history=working_history, system_instruction=dynamic_system_instruction + (f"\n\n[Summary of earlier conversation]: {compaction_notes}" if compaction_notes else ""))
+
+                # token tracking
+                usage = getattr(interaction, "usage", None)
+                if usage:
+                    last_input_tokens = getattr(usage, "total_tokens", last_input_tokens)
+
+                # CustomStreamWrapper does not expose ``choices`` in its static type,
+                # although the completed interaction provides it at runtime.
+                choices = getattr(interaction, "choices", None)
+                if not choices:
+                    iter_span.set_status(Status(StatusCode.OK))
+                    continue
+                message = choices[0].message
+                tool_calls = getattr(message, "tool_calls", None)
+                content = getattr(message, "content", None)
+
+                if content and not tool_calls:
+                    model_step = {
+                        "role": "assistant",
+                        "content": content,
+                    }
+                    await append_step(model_step, steps_history, working_history, current_session_history, session_id, store, turn_type)
+                    
+                    turn_span.set_attribute("outcome", "success")
+                    turn_span.set_status(Status(StatusCode.OK))
+                    iter_span.set_status(Status(StatusCode.OK))
+                    # print(f"\n\nAgent: {content}")
+                    if usage:
+                        usage_dict = {
+                            "prompt_tokens": getattr(usage, "prompt_tokens", 0) or 0,
+                            "completion_tokens": getattr(usage, "completion_tokens", 0) or 0,
+                            "total_tokens": getattr(usage, "total_tokens", 0) or 0,
+                        }
+                        await _emit("usage", usage_dict)
+                    return content
+    
+                if not tool_calls:
+                    iter_span.set_status(Status(StatusCode.OK))
+                    continue    
+
+                function_calls = []
+                for tool_call in tool_calls:
+                    if tool_call.type == "function":
+                        fn_name = tool_call.function.name
+                        fn_args = json.loads(tool_call.function.arguments) if isinstance(tool_call.function.arguments, str) else tool_call.function.arguments
+                        fn_id = tool_call.id
+                        function_calls.append((fn_name, fn_args, fn_id))
+    
+                assistant_tool_step = {
+                    "role": "assistant",
+                    "content": content,
+                    "tool_calls": [t.model_dump() for t in tool_calls]
+                }
+                await append_step(assistant_tool_step, steps_history, working_history, current_session_history, session_id, store, turn_type)
+    
+    
+                for fn_name, fn_args, _ in function_calls:
+                    await _emit("tool_call", f"{fn_name}({fn_args})")
+    
+                results = await asyncio.gather(
+                    *(asyncio.wait_for(
+                        run_tool(fn_name=fn_name, fn_args=dict(fn_args), mcp_client=mcp_client, session_id=session_id, turn_id=turn_id),
+                        timeout=120.0  # 2 min per tool call; prevents hung MCP servers from blocking the turn
+                    ) for fn_name, fn_args, _ in function_calls),
+                    return_exceptions=True,
+                )
+                final_results = []
+                for (fn_name, fn_args, fn_id), result in zip(function_calls, results):
+                    if isinstance(result, ConfirmationRequired):
+                        if adapter and hasattr(adapter, "ask"):
+                            confirm = await adapter.ask(result.message, result.resume_args)
+                        else:
+                            if adapter and hasattr(adapter, "emit"):
+                                adapter.emit("confirm", result.message)
+                            else:
+                                print(f"\nConfirmation needed: {result.message}")
+                            confirm = await asyncio.to_thread(input, "Allow this? [y/n]: ")
+                            confirm = confirm.strip().lower() == "y"
+
+                        if confirm:
+                            resumed_args = {**fn_args, **result.resume_args}
+                            result = await run_tool(fn_name=fn_name, fn_args=resumed_args, mcp_client=mcp_client, session_id=session_id, turn_id=turn_id)
+                        else:
+                            result = "Error: User declined to allow this action."
+                
+                    elif isinstance(result, Exception):
+                        result = f"Error: {result}"
+                
+                    final_results.append((fn_name, fn_id, result))
+                    await _emit("tool_result", f"{fn_name}: {str(result)[:200]}")
+                
+                for fn_name, fn_id, result in final_results:
+                    result_step = {
+                        "role": "tool",
+                        "name": fn_name,
+                        "tool_call_id": fn_id,
+                        "content": str(result)
+                    }
+                    await append_step(result_step, steps_history, working_history, current_session_history, session_id, store, turn_type)
+                    iter_span.set_status(Status(StatusCode.OK))
+    
+        else:
+            msg = f"Reached maximum iterations ({MAX_ITERATIONS}) without receiving a model output. Ending the agent loop."
+            if adapter and hasattr(adapter, "emit"):
+                adapter.emit("system", msg)
+            else:
+                print(msg)
+            turn_span.set_attribute("outcome", "max_iterations_exceeded")  
+            turn_span.set_status(Status(StatusCode.ERROR, "max_iterations_exceeded"))
+            return msg
+    

dostuff/agent/run_tool.py

@@ -0,0 +1,52 @@
+from dostuff.tools.definitions import TOOL_MAP
+from typing import Any
+from dostuff.lib.tracing import traced
+import inspect
+import asyncio
+from dostuff.tools.mcp.call_mcp_tool import _impl_call_mcp_tool
+from dostuff.tools.mcp.get_mcp_tool_details import _impl_get_mcp_tool_details
+from dostuff.tools.mcp.search_mcp_tools import _impl_search_mcp_tools
+from dostuff.lib.mcp.mcp_client import MCPClient
+from dostuff.tools.delegate_to_subagent import _impl_delegate_to_subagent
+
+MCP_META_TOOLS = {
+    "search_mcp_tools": _impl_search_mcp_tools,
+    "get_mcp_tool_details": _impl_get_mcp_tool_details,
+    "call_mcp_tool": _impl_call_mcp_tool,
+}
+
+SUBAGENT_META_TOOLS = {
+    "delegate_to_subagent": _impl_delegate_to_subagent
+}
+
+@traced("tool_call")
+async def run_tool(fn_name: str | None, fn_args: dict[str, Any], mcp_client: MCPClient | None = None, session_id: str | None = None, turn_id: str | None = None) -> Any:
+    if not isinstance(fn_name, str):
+        raise ValueError("Tool name must be a string.")
+
+    if fn_name in SUBAGENT_META_TOOLS:
+        if not session_id or not turn_id or not mcp_client:
+            raise ValueError(f"Cannot spawn subagent without all required arguments.")
+        fn = SUBAGENT_META_TOOLS[fn_name]
+        if inspect.iscoroutinefunction(fn):
+            return await fn(**fn_args, mcp_client=mcp_client, session_id = session_id, turn_id=turn_id)
+        else:
+            return await asyncio.to_thread(fn, **fn_args, mcp_client=mcp_client, session_id = session_id, turn_id=turn_id)
+
+    if fn_name in MCP_META_TOOLS:
+        if not mcp_client:
+            raise ValueError(f"Cannot execute MCP tool '{fn_name}' without an active mcp_client.")
+        fn = MCP_META_TOOLS[fn_name]
+        if inspect.iscoroutinefunction(fn):
+            return await fn(**fn_args, mcp_client=mcp_client)
+        else:
+            return await asyncio.to_thread(fn, **fn_args, mcp_client=mcp_client)
+
+    if fn_name not in TOOL_MAP:
+        raise KeyError(f"Tool '{fn_name}' not found.")
+
+    fn = TOOL_MAP[fn_name]
+    if inspect.iscoroutinefunction(fn):
+        return await fn(**fn_args)
+    else:
+        return await asyncio.to_thread(fn, **fn_args)

dostuff/cli.py

@@ -0,0 +1,105 @@
+import typer
+import sys
+
+app = typer.Typer()
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context = typer.Option(None),
+    session: str = typer.Option(None, "--session", help="Session ID (default: new UUID)"),
+    user: str = typer.Option(None, "--user", help="User ID (default: from ~/.dostuff/user_id)"),
+):
+    if ctx.invoked_subcommand is not None:
+        return  # subcommand (init/config/doctor/session_list/resume) — don't start agent
+    from dostuff.config import Config
+
+    config = Config()
+    user_id = user or config.get_user_id()
+    session_id = session or (sys.argv[0] + "_" + __import__("uuid").uuid4().hex[:8])
+    if session is None and session_id.startswith(sys.argv[0]):
+        session_id = __import__("uuid").uuid4().hex[:16]
+    typer.echo(f"USER: {user_id}  SESSION: {session_id}")
+    typer.echo(f"DATA_DIR: {config.get_data_dir()}")
+    typer.echo("Starting TUI...")
+    typer.echo("STARTING DoStuff...")
+    # Real TUI — default experience (not skeleton)
+    from dostuff.cli_tui import DostuffTUI
+    tui_app = DostuffTUI(session_id=session_id, user_id=user_id)
+    tui_app.run()
+
+@app.command()
+def init():
+    import pathlib
+    cwd = pathlib.Path.cwd()
+    proj_dir = cwd / ".dostuff"
+    proj_dir.mkdir(exist_ok=True)
+    
+    # Create project config.yaml with template
+    config_template = """# Project-specific config (overrides ~/.dostuff/config.yaml)
+# Uncomment any section below to override the global config.
+# Full reference: https://github.com/<you>/dostuff/blob/main/config.example.yaml
+
+# data:
+#   mode: "project"  # use project data dir instead of global
+
+# mcp:
+#   config_path: "mcp_config.json"  # project-specific MCP servers
+
+# model:
+#   name: "openai/gpt-4o-mini"  # litellm format
+#   api_key_env: "OPENAI_API_KEY"  # env var with key (never put key in YAML)
+
+# tracing:
+#   enabled: false
+#   exporter: "otlp"
+"""
+    (proj_dir / "config.yaml").write_text(config_template)
+    
+    # Create directories
+    (proj_dir / "skills").mkdir(exist_ok=True)
+    
+    typer.echo(f"Initialized project at {cwd}")
+
+@app.command()
+def config():
+    from dostuff.config import Config
+
+    cfg = Config()
+    typer.echo(f"Global config: {cfg.global_path}")
+    # typer.echo(f"Data mode: {cfg.raw.get('data',{}).get('mode','global')}")
+    typer.echo(f"Data dir: {cfg.get_data_dir()}")
+    typer.echo(f"User ID: {cfg.get_user_id()}")
+
+@app.command()
+def doctor():
+    typer.echo("Health check: dostuff package installed.")
+    from dostuff.config import Config
+
+    cfg = Config()
+    typer.echo(f"  Global config: {cfg.global_path} (exists={cfg.global_path.exists()})")
+    cwd = __import__('pathlib').Path.cwd()
+    proj = cwd / ".dostuff" / "config.yaml"
+    typer.echo(f"  Project config: {proj} (exists={proj.exists()})")
+    typer.echo(f"  User ID file: {cfg.user_id_path} (exists={cfg.user_id_path.exists()})")
+    typer.echo(f"  Data dir: {cfg.get_data_dir()} (exists={cfg.get_data_dir().exists()})")
+
+@app.command()
+def session_list():
+    import asyncio
+    from dostuff.memory import SQLiteSessionStore
+    from dostuff.config import Config
+
+    async def _run():
+        cfg = Config()
+        store = SQLiteSessionStore(db_path=str(cfg.get_data_dir() / "sessions.db"))
+        rows = await store.list()
+        if not rows:
+            typer.echo("No past sessions.")
+            return
+        typer.echo(f"{'SESSION':<36} | {'WORKING_DIR':<60}")
+        typer.echo("-" * 100)
+        for sid, wd in rows:
+            typer.echo(f"{sid:<36} | {str(wd):<60}")
+    asyncio.run(_run())
+
+