task-agent 1.2.1__tar.gz → 1.3.1__tar.gz

{task_agent-1.2.1 → task_agent-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: task-agent
-Version: 1.2.1
+Version: 1.3.1
 Summary: A prioritized, file-based task queue for autonomous agentic workers
 Author-email: Mark Stouffer <1802850+InTEGr8or@users.noreply.github.com>
 License: MIT

{task_agent-1.2.1 → task_agent-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task-agent"
-version = "1.2.1"
+version = "1.3.1"
 description = "A prioritized, file-based task queue for autonomous agentic workers"
 readme = "README.md"
 requires-python = ">=3.12"

{task_agent-1.2.1 → task_agent-1.3.1}/src/taskagent/chat/__init__.py

@@ -11,13 +11,19 @@ from taskagent.chat.discovery import (
     DiscoveredChat,
     discover_agent_chats,
 )
+from taskagent.chat.last_used import (
+    AgentLastUsedInfo,
+    get_last_active_agents,
+)
 
 __all__ = [
+    "AgentLastUsedInfo",
     "ChatConfig",
     "DiscoveredChat",
     "RetentionConfig",
     "S3Config",
     "SummarizationConfig",
     "discover_agent_chats",
+    "get_last_active_agents",
     "load_chat_config",
 ]

task_agent-1.3.1/src/taskagent/chat/last_used.py

@@ -0,0 +1,200 @@
+"""Module for discovering and extracting last-active agent session info."""
+
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, List, Optional, Tuple
+
+from agent_registry import (
+    AgentCLIInfo,
+    DiscoveredChat,
+    discover_agent_chats,
+    get_agent_cli_registry,
+)
+from taskagent.store_registry import project_host_root
+
+
+@dataclass
+class AgentLastUsedInfo:
+    """Information on the last active session for an agent CLI in a repository."""
+
+    agent_id: str
+    agent_name: str
+    description: str
+    last_active: datetime
+    last_user_comment: str
+    log_path: Path
+
+
+def _extract_text(node: Any) -> str:
+    """Recursively extract string content from dicts, lists, or primitive strings."""
+    if isinstance(node, str):
+        return node
+    elif isinstance(node, dict):
+        if "text" in node and isinstance(node["text"], str):
+            return node["text"]
+        if "content" in node:
+            return _extract_text(node["content"])
+        if "message" in node:
+            return _extract_text(node["message"])
+    elif isinstance(node, list):
+        parts = [_extract_text(item) for item in node]
+        return " ".join(p for p in parts if p)
+    return ""
+
+
+def _is_user_role(role_val: Any) -> bool:
+    if isinstance(role_val, str):
+        r = role_val.lower()
+        return r in ("user", "say", "user_input", "user_explicit", "human", "user_feedback")
+    return False
+
+
+def _parse_last_user_comment_and_timestamp(
+    discovered: DiscoveredChat,
+) -> Tuple[datetime, str]:
+    """Extract timestamp and first 200 chars of last user comment from chat log file."""
+    path = discovered.path
+    file_mtime = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc)
+    user_comment = ""
+
+    if not path.is_file():
+        return file_mtime, user_comment
+
+    try:
+        if discovered.parser_type == "jsonl":
+            text_lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+            for line in reversed(text_lines):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data = json.loads(line)
+                    if isinstance(data, dict):
+                        msg = data.get("message")
+                        role = (
+                            data.get("type")
+                            or data.get("role")
+                            or data.get("source")
+                            or (msg.get("role") if isinstance(msg, dict) else None)
+                        )
+                        if _is_user_role(role):
+                            raw_comment = _extract_text(msg if msg else data).strip()
+                            if (
+                                raw_comment
+                                and not raw_comment.startswith("<local-command-")
+                                and not raw_comment.startswith("<command-name>")
+                            ):
+                                user_comment = raw_comment
+                                break
+                except Exception:
+                    continue
+
+        elif discovered.parser_type == "json":
+            raw_text = path.read_text(encoding="utf-8", errors="replace")
+            data = json.loads(raw_text)
+            messages = []
+            if isinstance(data, list):
+                messages = data
+            elif isinstance(data, dict):
+                messages = (
+                    data.get("messages")
+                    or data.get("steps")
+                    or data.get("history")
+                    or []
+                )
+
+            if isinstance(messages, list):
+                for msg in reversed(messages):
+                    if isinstance(msg, dict):
+                        role = (
+                            msg.get("say")
+                            or msg.get("role")
+                            or msg.get("type")
+                            or msg.get("source")
+                        )
+                        if _is_user_role(role):
+                            raw_comment = _extract_text(msg).strip()
+                            if raw_comment:
+                                user_comment = raw_comment
+                                break
+
+        elif discovered.parser_type == "markdown":
+            raw_text = path.read_text(encoding="utf-8", errors="replace")
+            text_lines = raw_text.splitlines()
+            user_blocks = []
+            current_block = []
+            in_user = False
+            for line in text_lines:
+                if line.startswith("#") or line.startswith("> "):
+                    if in_user and current_block:
+                        user_blocks.append("\n".join(current_block).strip())
+                        current_block = []
+                    in_user = ("user" in line.lower() or "human" in line.lower())
+                elif in_user:
+                    current_block.append(line)
+            if in_user and current_block:
+                user_blocks.append("\n".join(current_block).strip())
+            if user_blocks:
+                user_comment = user_blocks[-1]
+
+    except Exception:
+        pass
+
+    user_comment = " ".join(user_comment.split())
+
+    if len(user_comment) > 200:
+        user_comment = user_comment[:197] + "..."
+
+    return file_mtime, user_comment
+
+
+def get_last_active_agents(
+    project_dir: Optional[Path] = None,
+    limit: int = 5,
+) -> List[AgentLastUsedInfo]:
+    """Find and rank most recently active AI agent CLIs in a project repository."""
+    if project_dir is None:
+        project_dir = Path.cwd()
+
+    host_root = project_host_root(project_dir)
+    discovered_chats = discover_agent_chats(project_dir=host_root)
+    registry = get_agent_cli_registry()
+
+    agent_chats_map: dict[str, List[DiscoveredChat]] = {}
+    for chat in discovered_chats:
+        agent_chats_map.setdefault(chat.agent_id, []).append(chat)
+
+    results: List[AgentLastUsedInfo] = []
+
+    for agent_id, chats in agent_chats_map.items():
+        agent_info: Optional[AgentCLIInfo] = registry.get(agent_id)
+        name = agent_info.name if agent_info else agent_id.capitalize()
+        description = agent_info.description if agent_info else ""
+
+        newest_mtime: Optional[datetime] = None
+        newest_comment: str = ""
+        newest_path: Optional[Path] = None
+
+        for chat in chats:
+            mtime, comment = _parse_last_user_comment_and_timestamp(chat)
+            if newest_mtime is None or mtime > newest_mtime:
+                newest_mtime = mtime
+                newest_comment = comment
+                newest_path = chat.path
+
+        if newest_mtime is not None and newest_path is not None:
+            results.append(
+                AgentLastUsedInfo(
+                    agent_id=agent_id,
+                    agent_name=name,
+                    description=description,
+                    last_active=newest_mtime,
+                    last_user_comment=newest_comment,
+                    log_path=newest_path,
+                )
+            )
+
+    results.sort(key=lambda item: item.last_active, reverse=True)
+    return results[:limit]

{task_agent-1.2.1 → task_agent-1.3.1}/src/taskagent/cli.py

@@ -4232,6 +4232,63 @@ def cmd_agent_import(
             sys.exit(1)
 
 
+def cmd_agent_last_used(
+    console: Console,
+    path_arg: Optional[str] = None,
+    limit: int = 5,
+    json_format: bool = False,
+) -> None:
+    """Handler for 'ta agent last-used' subcommand."""
+    from rich import box
+    from taskagent.chat.last_used import get_last_active_agents
+
+    target_path = Path(path_arg).resolve() if path_arg else Path.cwd()
+    results = get_last_active_agents(project_dir=target_path, limit=limit)
+
+    if json_format:
+        output = [
+            {
+                "agent_id": item.agent_id,
+                "agent_name": item.agent_name,
+                "description": item.description,
+                "last_active": item.last_active.isoformat(),
+                "last_user_comment": item.last_user_comment,
+                "log_path": str(item.log_path),
+            }
+            for item in results
+        ]
+        print(json.dumps(output, indent=2))
+        return
+
+    if not results:
+        console.print(
+            f"[yellow]No agent chat sessions found for repository at [bold]{target_path}[/bold].[/yellow]"
+        )
+        return
+
+    console.print(
+        f"\n[bold green]🤖 Recently Active AI Agents[/bold green] [dim]({target_path})[/dim]\n"
+    )
+
+    table = Table(box=box.ROUNDED, show_header=True, header_style="bold cyan")
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Agent CLI", style="bold yellow")
+    table.add_column("Last Active", style="green")
+    table.add_column("Last Comment Snippet", style="dim white")
+
+    for idx, item in enumerate(results, start=1):
+        rel_time = item.last_active.strftime("%Y-%m-%d %H:%M:%S UTC")
+        comment_snippet = item.last_user_comment if item.last_user_comment else "[dim](no prompt comment logged)[/dim]"
+        table.add_row(
+            str(idx),
+            item.agent_name,
+            rel_time,
+            comment_snippet,
+        )
+
+    console.print(table)
+
+
 def cmd_version(
     console: Console,
     promote: Optional[str] = None,
@@ -6055,6 +6112,27 @@ Start working on a task. This command automates the following workflow:
         action="store_true",
         help="Output result as JSON",
     )
+    agent_last_used_p = agent_sub.add_parser(
+        "last-used",
+        help="List AI coding agents recently active in this repository",
+    )
+    agent_last_used_p.add_argument(
+        "path",
+        nargs="?",
+        default=None,
+        help="Target repository directory (defaults to cwd)",
+    )
+    agent_last_used_p.add_argument(
+        "--limit",
+        type=int,
+        default=5,
+        help="Maximum number of active agents to return (default: 5)",
+    )
+    agent_last_used_p.add_argument(
+        "--json",
+        action="store_true",
+        help="Output result as JSON",
+    )
 
     # plan
     subparsers.add_parser("plan", help="View or edit the project plan")
@@ -6738,9 +6816,16 @@ TA_STRATEGY_COOLDOWN_HOURS environment variable.
                 file_path=args.file,
                 json_format=args.json,
             )
+        elif args.agent_subcommand == "last-used":
+            cmd_agent_last_used(
+                console,
+                path_arg=args.path,
+                limit=args.limit,
+                json_format=args.json,
+            )
         else:
             console.print(
-                "[yellow]Unknown agent subcommand. Use 'ta agent import'.[/yellow]"
+                "[yellow]Unknown agent subcommand. Use 'ta agent import' or 'ta agent last-used'.[/yellow]"
             )
     elif args.command == "push":
         cmd_push(console, manager)

{task_agent-1.2.1 → task_agent-1.3.1}/src/taskagent/mcp.py

@@ -1431,6 +1431,47 @@ def import_agent_tasks(
     )
 
 
+@mcp.tool()
+def get_last_active_agent(
+    path: str = "",
+    limit: int = 5,
+) -> str:
+    """Find and rank most recently active AI coding agent CLIs in a project repository.
+
+    Args:
+        path: Target repository directory path (defaults to working directory if empty).
+        limit: Maximum number of active agents to return (default: 5).
+
+    Returns:
+        Formatted summary list of recently active AI agent CLIs, sorted descending by last active date,
+        including description and first 200 characters of the last user comment.
+    """
+    from pathlib import Path
+    from taskagent.chat.last_used import get_last_active_agents
+
+    target_path = Path(path).resolve() if path and path.strip() else Path.cwd()
+    results = get_last_active_agents(project_dir=target_path, limit=limit)
+
+    if not results:
+        return f"No agent chat sessions found for repository at {target_path}."
+
+    lines = [f"### 🤖 Recently Active AI Agents ({target_path})\n"]
+    for idx, item in enumerate(results, start=1):
+        rel_time = item.last_active.strftime("%Y-%m-%d %H:%M:%S UTC")
+        comment_snippet = (
+            item.last_user_comment
+            if item.last_user_comment
+            else "(no prompt comment logged)"
+        )
+        lines.append(f"{idx}. **{item.agent_name}** (`{item.agent_id}`)")
+        lines.append(f"   - **Description**: {item.description}")
+        lines.append(f"   - **Last Active**: {rel_time}")
+        lines.append(f"   - **Last Comment Snippet**: {comment_snippet}")
+        lines.append("")
+
+    return "\n".join(lines).strip()
+
+
 def run_mcp_server():
     """Main entry point to run the MCP server."""
     mcp.run()

task_agent-1.3.1/tests/test_chat_last_used.py

@@ -0,0 +1,86 @@
+import json
+
+from agent_registry.models import DiscoveredChat
+from taskagent.chat.last_used import (
+    AgentLastUsedInfo,
+    _parse_last_user_comment_and_timestamp,
+    get_last_active_agents,
+)
+
+
+def test_parse_last_user_comment_jsonl(tmp_path):
+    log_file = tmp_path / "claude_session.jsonl"
+    lines = [
+        json.dumps({"type": "system", "content": "Init"}),
+        json.dumps({"type": "user", "content": "First prompt from user"}),
+        json.dumps({"type": "assistant", "content": "AI response"}),
+        json.dumps({"type": "user", "content": "Please refactor the database connector for production"}),
+    ]
+    log_file.write_text("\n".join(lines))
+
+    chat = DiscoveredChat(agent_id="claude", path=log_file, parser_type="jsonl")
+    mtime, comment = _parse_last_user_comment_and_timestamp(chat)
+
+    assert comment == "Please refactor the database connector for production"
+    assert mtime is not None
+
+
+def test_parse_last_user_comment_json(tmp_path):
+    log_file = tmp_path / "session.json"
+    data = {
+        "messages": [
+            {"say": "user", "text": "Initial task message"},
+            {"say": "assistant", "text": "Working on it"},
+            {"say": "user", "text": "Add unit tests for the chat discovery module"},
+        ]
+    }
+    log_file.write_text(json.dumps(data))
+
+    chat = DiscoveredChat(agent_id="agy", path=log_file, parser_type="json")
+    mtime, comment = _parse_last_user_comment_and_timestamp(chat)
+
+    assert comment == "Add unit tests for the chat discovery module"
+
+
+def test_parse_last_user_comment_markdown(tmp_path):
+    log_file = tmp_path / ".aider.chat.history.md"
+    content = """# session log
+
+#### user
+Fix memory leak in background worker queue
+
+#### assistant
+Analyzing queue implementation...
+"""
+    log_file.write_text(content)
+
+    chat = DiscoveredChat(agent_id="aider", path=log_file, parser_type="markdown")
+    mtime, comment = _parse_last_user_comment_and_timestamp(chat)
+
+    assert "Fix memory leak in background worker queue" in comment
+
+
+def test_get_last_active_agents(monkeypatch, tmp_path):
+    f1 = tmp_path / "claude.jsonl"
+    f1.write_text(json.dumps({"type": "user", "content": "Claude task"}))
+
+    f2 = tmp_path / "agy.json"
+    f2.write_text(json.dumps([{"say": "user", "text": "Antigravity task"}]))
+
+    discovered = [
+        DiscoveredChat(agent_id="claude", path=f1, parser_type="jsonl"),
+        DiscoveredChat(agent_id="agy", path=f2, parser_type="json"),
+    ]
+
+    monkeypatch.setattr(
+        "taskagent.chat.last_used.discover_agent_chats",
+        lambda project_dir=None: discovered,
+    )
+
+    results = get_last_active_agents(project_dir=tmp_path, limit=5)
+    assert len(results) == 2
+    agent_ids = {r.agent_id for r in results}
+    assert agent_ids == {"claude", "agy"}
+    for r in results:
+        assert isinstance(r, AgentLastUsedInfo)
+        assert r.description != ""

{task_agent-1.2.1 → task_agent-1.3.1}/tests/test_mcp.py

@@ -638,6 +638,7 @@ EXPECTED_TOOLS = {
     "ack_inbox",
     "watch_inbox_mcp",
     "import_agent_tasks",
+    "get_last_active_agent",
     "start_task",
     "run_task",
     "get_store_log",

{task_agent-1.2.1 → task_agent-1.3.1}/uv.lock

@@ -1441,7 +1441,7 @@ wheels = [
 
 [[package]]
 name = "task-agent"
-version = "1.2.1"
+version = "1.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "agent-cli-registry" },