task-agent 0.1.321__tar.gz → 0.1.342__tar.gz

{task_agent-0.1.321 → task_agent-0.1.342}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: task-agent
-Version: 0.1.321
+Version: 0.1.342
 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-0.1.321 → task_agent-0.1.342}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task-agent"
-version = "0.1.321"
+version = "0.1.342"
 description = "A prioritized, file-based task queue for autonomous agentic workers"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -39,7 +39,7 @@ dev = [
 ]
 
 [tool.bumpversion]
-current_version = "0.1.321"
+current_version = "0.1.342"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "version = \"{current_version}\""

{task_agent-0.1.321 → task_agent-0.1.342}/src/taskagent/cli.py

@@ -332,8 +332,130 @@ def render_issue(console: Console, issue: Issue, issue_file: Path):
         console.print(md)
 
 
+def maybe_show_strategy(console: Console, manager: TaskAgent) -> bool:
+    """Show the project strategy panel if the cooldown has elapsed.
+
+    Returns True if the strategy was displayed.
+    """
+    if not manager.should_show_strategy():
+        return False
+
+    content = manager.get_strategy()
+    if not content:
+        return False
+
+    # Strip the H1 header if present — we use it as the panel title instead
+    lines = content.split("\n")
+    title = "Strategy"
+    body_lines = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("# ") and title == "Strategy":
+            title = stripped.lstrip("# ").strip()
+            continue
+        # Skip HTML comments (the hint comment)
+        if stripped.startswith("<!--") and stripped.endswith("-->"):
+            continue
+        body_lines.append(line)
+
+    body = "\n".join(body_lines).strip()
+    if not body or body == "_Define the current strategic direction for this project._":
+        return False
+
+    meta = manager.get_strategy_meta()
+    last_shown = meta.get("last_shown_at", "never")
+    if last_shown != "never":
+        try:
+            from datetime import datetime as dt
+
+            last_dt = dt.fromisoformat(last_shown)
+            elapsed = (dt.now() - last_dt).total_seconds()
+            if elapsed < 3600:
+                age = f"{int(elapsed / 60)}m ago"
+            elif elapsed < 86400:
+                age = f"{int(elapsed / 3600)}h ago"
+            else:
+                age = f"{int(elapsed / 86400)}d ago"
+            subtitle = f"last shown {age} · ta strategy"
+        except Exception:
+            subtitle = "ta strategy"
+    else:
+        subtitle = "ta strategy"
+
+    # Construct a clean Markdown blockquote
+    lines = [f"> 📐 **{title}**", ">"]
+    for line in body.split("\n"):
+        lines.append(f"> {line}")
+    lines.append(">")
+    lines.append(f"> *{subtitle}*")
+
+    console.print(Markdown("\n".join(lines)))
+    console.print()
+    manager.update_strategy_last_shown()
+    return True
+
+
+def cmd_strategy(
+    console: Console,
+    manager: TaskAgent,
+    action: Optional[str] = None,
+):
+    """View, edit, or initialize the project strategy."""
+    if action == "init":
+        path = manager.init_strategy()
+        console.print(f"[bold green]Strategy initialized:[/bold green] {path}")
+        console.print("[dim]Edit it with: ta strategy edit[/dim]")
+        return
+
+    if action == "edit":
+        path = manager.init_strategy()
+        editor = get_editor()
+        subprocess.run([editor, str(path)])
+        console.print("[bold green]Strategy updated.[/bold green]")
+        return
+
+    # Default: view
+    content = manager.get_strategy()
+    if not content:
+        console.print(
+            "[yellow]No strategy defined yet.[/yellow]\n"
+            "[dim]Run [bold]ta strategy init[/bold] to create one.[/dim]"
+        )
+        return
+
+    lines = content.split("\n")
+    title = "Strategy"
+    body_lines = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("# ") and title == "Strategy":
+            title = stripped.lstrip("# ").strip()
+            continue
+        if stripped.startswith("<!--") and stripped.endswith("-->"):
+            continue
+        body_lines.append(line)
+
+    body = "\n".join(body_lines).strip()
+
+    meta = manager.get_strategy_meta()
+    last_shown = meta.get("last_shown_at", "never")
+
+    # Construct a clean Markdown blockquote
+    lines = [f"> 📐 **{title}**", ">"]
+    if body:
+        for line in body.split("\n"):
+            lines.append(f"> {line}")
+    else:
+        lines.append("> *Empty strategy — edit it with: ta strategy edit*")
+    lines.append(">")
+    lines.append(f"> *last shown: {last_shown} · ta strategy edit*")
+
+    console.print(Markdown("\n".join(lines)))
+
+
 def cmd_next(console: Console, manager: TaskAgent):
     """Show the top issue."""
+    maybe_show_strategy(console, manager)
     next_issue = manager.get_next_issue()
     if not next_issue:
         console.print(f"[yellow]No issues found in {manager.mission_path}[/yellow]")
@@ -1405,6 +1527,8 @@ def cmd_list(
     output_format: str = "table",
 ):
     """List all issues in mission.usv."""
+    if output_format == "table":
+        maybe_show_strategy(console, manager)
     issues = manager.sync_mission()
     if not issues:
         if output_format == "json":
@@ -1555,6 +1679,8 @@ def cmd_active(
 ) -> Optional[Issue]:
     """Move an issue to active status, or list active tasks."""
     issues = manager.load_mission()
+    if not slug_part and list_if_none and not silent:
+        maybe_show_strategy(console, manager)
     if not slug_part and list_if_none:
         active_issues = [i for i in issues if i.status == "active"]
         if not silent:
@@ -3207,6 +3333,31 @@ Start working on a task. This command automates the following workflow:
     # plan
     subparsers.add_parser("plan", help="View or edit the project plan")
 
+    # strategy
+    strategy_parser = subparsers.add_parser(
+        "strategy",
+        help="View, edit, or initialize the project strategy",
+        description="""
+Manage the project's strategic direction document.
+
+The strategy is a concise statement of the project's current direction, goals,
+and priorities. It is displayed periodically at the top of 'list', 'next', and
+'active' commands to keep all workers aligned.
+
+Usage:
+  ta strategy          View the current strategy
+  ta strategy edit     Open the strategy in your $EDITOR
+  ta strategy init     Create a starter strategy file
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    strategy_parser.add_argument(
+        "action",
+        nargs="?",
+        choices=["edit", "init"],
+        help="Action to perform (default: view)",
+    )
+
     # push
     subparsers.add_parser("push", help="Push the mission repository to origin")
 
@@ -3389,6 +3540,8 @@ Start working on a task. This command automates the following workflow:
         cmd_push(console, manager)
     elif args.command == "plan":
         cmd_plan(console, manager)
+    elif args.command == "strategy":
+        cmd_strategy(console, manager, action=args.action)
     elif args.command == "commit":
         if args.target == "repo":
             cmd_commit(console, manager, message=args.message, should_push=args.push)

{task_agent-0.1.321 → task_agent-0.1.342}/src/taskagent/manager.py

@@ -1210,3 +1210,84 @@ class TaskAgent:
         self.sync_mission()
 
         return len(new_issues), len(existing_issues) - len(present_issues)
+
+    # ── Strategy ─────────────────────────────────────────────────────
+
+    @property
+    def strategy_dir(self) -> Path:
+        """Path to the strategy directory."""
+        return self.issues_root / "strategy"
+
+    @property
+    def strategy_file(self) -> Path:
+        """Path to the strategy README."""
+        return self.strategy_dir / "README.md"
+
+    @property
+    def strategy_meta_file(self) -> Path:
+        """Path to the strategy metadata file."""
+        return self.strategy_dir / ".meta.json"
+
+    def get_strategy(self) -> Optional[str]:
+        """Read the strategy content. Returns None if no strategy file exists."""
+        if not self.strategy_file.exists():
+            return None
+        try:
+            content = self.strategy_file.read_text(encoding="utf-8").strip()
+            return content if content else None
+        except Exception:
+            return None
+
+    def get_strategy_meta(self) -> dict:
+        """Read strategy metadata (last_shown_at, cooldown_hours)."""
+        if not self.strategy_meta_file.exists():
+            return {}
+        try:
+            with self.strategy_meta_file.open("r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    def update_strategy_last_shown(self) -> None:
+        """Update the timestamp of when the strategy was last displayed."""
+        self.strategy_dir.mkdir(parents=True, exist_ok=True)
+        meta = self.get_strategy_meta()
+        meta["last_shown_at"] = datetime.now().isoformat()
+        with self.strategy_meta_file.open("w", encoding="utf-8") as f:
+            json.dump(meta, f, indent=2)
+
+    def should_show_strategy(self, cooldown_hours: float = 2.0) -> bool:
+        """Check if enough time has elapsed to display the strategy again.
+
+        Returns True if:
+        - A strategy file exists with content, AND
+        - The strategy has never been shown, OR
+        - At least `cooldown_hours` have passed since last shown.
+        """
+        content = self.get_strategy()
+        if not content:
+            return False
+
+        meta = self.get_strategy_meta()
+        last_shown = meta.get("last_shown_at")
+        if not last_shown:
+            return True
+
+        try:
+            last_dt = datetime.fromisoformat(last_shown)
+            elapsed = (datetime.now() - last_dt).total_seconds()
+            return elapsed >= cooldown_hours * 3600
+        except (ValueError, TypeError):
+            return True
+
+    def init_strategy(self) -> Path:
+        """Create the strategy directory and a starter README if it doesn't exist."""
+        self.strategy_dir.mkdir(parents=True, exist_ok=True)
+        if not self.strategy_file.exists():
+            self.strategy_file.write_text(
+                "# Strategy\n\n"
+                "_Define the current strategic direction for this project._\n\n"
+                "<!-- Keep this concise — it will be displayed periodically in CLI output. -->\n",
+                encoding="utf-8",
+            )
+        return self.strategy_file

{task_agent-0.1.321 → task_agent-0.1.342}/src/taskagent/mcp.py

@@ -17,6 +17,67 @@ def get_manager() -> TaskAgent:
     return discover()
 
 
+def _maybe_prepend_strategy(manager: TaskAgent, response: str) -> str:
+    """If the strategy cooldown has elapsed, prepend the strategy to the response."""
+    if hasattr(manager, "should_show_strategy") and manager.should_show_strategy():
+        if hasattr(manager, "get_strategy"):
+            strategy = manager.get_strategy()
+            if strategy:
+                # Strip the H1 header if present — we want to keep it clean and concise
+                lines = strategy.split("\n")
+                title = "Strategy"
+                body_lines = []
+                for line in lines:
+                    stripped = line.strip()
+                    if stripped.startswith("# ") and title == "Strategy":
+                        title = stripped.lstrip("# ").strip()
+                        continue
+                    # Skip HTML comments (the hint comment)
+                    if stripped.startswith("<!--") and stripped.endswith("-->"):
+                        continue
+                    body_lines.append(line)
+
+                body = "\n".join(body_lines).strip()
+                if (
+                    body
+                    and body
+                    != "_Define the current strategic direction for this project._"
+                ):
+                    if hasattr(manager, "update_strategy_last_shown"):
+                        manager.update_strategy_last_shown()
+                    # Construct clean Markdown blockquote for LLM/agent
+                    strategy_lines = [f"> 📐 **{title}**", ">"]
+                    for line in body.split("\n"):
+                        strategy_lines.append(f"> {line}")
+                    prefix = "\n".join(strategy_lines) + "\n\n"
+                    return prefix + response
+    return response
+
+
+@mcp.tool()
+def get_strategy() -> str:
+    """Retrieve the current project strategy statement.
+
+    This provides high-level principles, constraints, or goals that should guide development.
+    """
+    manager = get_manager()
+    if not hasattr(manager, "get_strategy"):
+        return "No strategy defined yet."
+    strategy = manager.get_strategy()
+    if not strategy:
+        return "No strategy defined yet."
+
+    # Strip HTML comments for the tool output to keep it clean
+    lines = strategy.split("\n")
+    body_lines = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("<!--") and stripped.endswith("-->"):
+            continue
+        body_lines.append(line)
+    return "\n".join(body_lines).strip()
+
+
 @mcp.tool()
 def list_tasks() -> str:
     """List all tasks in the current project's mission queue.
@@ -28,13 +89,16 @@ def list_tasks() -> str:
     manager = get_manager()
     issues = manager.sync_mission()
     if not issues:
-        return "No tasks found in the queue."
-
-    lines = []
-    for i in issues:
-        deps = f" (depends on: {', '.join(i.dependencies)})" if i.dependencies else ""
-        lines.append(f"[{i.priority}] {i.status.upper()}: {i.name}{deps}")
-    return "\n".join(lines)
+        res = "No tasks found in the queue."
+    else:
+        lines = []
+        for i in issues:
+            deps = (
+                f" (depends on: {', '.join(i.dependencies)})" if i.dependencies else ""
+            )
+            lines.append(f"[{i.priority}] {i.status.upper()}: {i.name}{deps}")
+        res = "\n".join(lines)
+    return _maybe_prepend_strategy(manager, res)
 
 
 @mcp.tool()
@@ -44,13 +108,16 @@ def list_active_tasks() -> str:
     issues = manager.sync_mission()
     active_issues = [i for i in issues if i.status == "active"]
     if not active_issues:
-        return "No active tasks found."
-
-    lines = []
-    for i in active_issues:
-        deps = f" (depends on: {', '.join(i.dependencies)})" if i.dependencies else ""
-        lines.append(f"[{i.priority}] ACTIVE: {i.name}{deps}")
-    return "\n".join(lines)
+        res = "No active tasks found."
+    else:
+        lines = []
+        for i in active_issues:
+            deps = (
+                f" (depends on: {', '.join(i.dependencies)})" if i.dependencies else ""
+            )
+            lines.append(f"[{i.priority}] ACTIVE: {i.name}{deps}")
+        res = "\n".join(lines)
+    return _maybe_prepend_strategy(manager, res)
 
 
 @mcp.tool()

task_agent-0.1.342/tests/conftest.py

@@ -0,0 +1,10 @@
+import os
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def clean_test_env(monkeypatch):
+    """Remove git and task-agent environment variables from the test process to prevent leakage."""
+    for key in list(os.environ.keys()):
+        if key.startswith("GIT_") or key.startswith("TA_"):
+            monkeypatch.delenv(key, raising=False)

{task_agent-0.1.321 → task_agent-0.1.342}/tests/test_cli.py

@@ -363,3 +363,66 @@ def test_cmd_done_cleanup(manager, temp_issues_dir, tmp_path):
     with patch("subprocess.run", side_effect=mock_run):
         cmd_done(console, manager, "done-clean-task", should_commit=False)
         assert not worktree_mock_path.exists()
+
+
+def test_maybe_show_strategy(manager):
+    from taskagent.cli import maybe_show_strategy
+
+    console = Console()
+
+    # 1. No strategy defined -> should return False
+    assert not maybe_show_strategy(console, manager)
+
+    # 2. Strategy initialized but has default starter content -> should return False
+    manager.init_strategy()
+    assert not maybe_show_strategy(console, manager)
+
+    # 3. Strategy has real content -> should return True
+    manager.strategy_file.write_text(
+        "# Real Strategy\nSome real strategic goals.", encoding="utf-8"
+    )
+    assert maybe_show_strategy(console, manager)
+
+    # 4. Strategy within cooldown -> should return False
+    assert not maybe_show_strategy(console, manager)
+
+
+def test_cmd_strategy(manager, monkeypatch):
+    from taskagent.cli import cmd_strategy
+
+    console = Console()
+
+    # Test action=None (view) when not initialized
+    # Should print message "No strategy defined yet"
+    with console.capture() as capture:
+        cmd_strategy(console, manager, action=None)
+    assert "No strategy defined yet" in capture.get()
+
+    # Test action="init"
+    with console.capture() as capture:
+        cmd_strategy(console, manager, action="init")
+    assert "Strategy initialized:" in capture.get()
+    assert manager.strategy_file.exists()
+
+    # Test action="edit"
+    import subprocess
+    import taskagent.cli as cli_module
+
+    called_run = []
+
+    def mock_run(args, **kwargs):
+        called_run.append(args)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    monkeypatch.setattr(cli_module, "get_editor", lambda: "nano")
+
+    with console.capture() as capture:
+        cmd_strategy(console, manager, action="edit")
+    assert "Strategy updated." in capture.get()
+    assert len(called_run) == 1
+    assert called_run[0] == ["nano", str(manager.strategy_file)]
+
+    # Test action=None (view) after initialization
+    with console.capture() as capture:
+        cmd_strategy(console, manager, action=None)
+    assert "Strategy" in capture.get()

{task_agent-0.1.321 → task_agent-0.1.342}/tests/test_manager.py

@@ -384,3 +384,62 @@ def test_api_update_dependencies(manager):
     # Clear dependencies
     manager.update_dependencies("task-b", "")
     assert manager.extract_deps(issue_file) == []
+
+
+def test_get_strategy_returns_none_when_no_file(manager):
+    assert manager.get_strategy() is None
+
+
+def test_get_strategy_reads_content(manager):
+    manager.strategy_dir.mkdir(parents=True, exist_ok=True)
+    manager.strategy_file.write_text("# Test Strategy\nContent here", encoding="utf-8")
+    assert manager.get_strategy() == "# Test Strategy\nContent here"
+
+
+def test_strategy_meta_roundtrip(manager):
+    assert manager.get_strategy_meta() == {}
+    manager.update_strategy_last_shown()
+    meta = manager.get_strategy_meta()
+    assert "last_shown_at" in meta
+    # Try parsing it
+    datetime.fromisoformat(meta["last_shown_at"])
+
+
+def test_should_show_strategy_no_file_returns_false(manager):
+    assert not manager.should_show_strategy()
+
+
+def test_should_show_strategy_first_time_returns_true(manager):
+    manager.init_strategy()
+    assert manager.should_show_strategy()
+
+
+def test_should_show_strategy_within_cooldown_returns_false(manager):
+    manager.init_strategy()
+    manager.update_strategy_last_shown()
+    assert not manager.should_show_strategy()
+
+
+def test_should_show_strategy_after_cooldown_returns_true(manager):
+    from datetime import datetime as dt, timedelta
+    import json
+
+    manager.init_strategy()
+    # Mock last shown far in the past
+    past_time = dt.now() - timedelta(hours=3)
+    manager.strategy_dir.mkdir(parents=True, exist_ok=True)
+    with manager.strategy_meta_file.open("w", encoding="utf-8") as f:
+        json.dump({"last_shown_at": past_time.isoformat()}, f)
+    assert manager.should_show_strategy(cooldown_hours=2.0)
+    assert not manager.should_show_strategy(cooldown_hours=4.0)
+
+
+def test_init_strategy_creates_files(manager):
+    assert not manager.strategy_dir.exists()
+    assert not manager.strategy_file.exists()
+    path = manager.init_strategy()
+    assert path == manager.strategy_file
+    assert manager.strategy_dir.exists()
+    assert manager.strategy_file.exists()
+    content = manager.strategy_file.read_text(encoding="utf-8")
+    assert "# Strategy" in content

{task_agent-0.1.321 → task_agent-0.1.342}/tests/test_mcp.py

@@ -8,6 +8,7 @@ from taskagent.models.issue import Issue
 def mock_manager():
     with patch("taskagent.mcp.get_manager") as mock:
         manager = MagicMock()
+        manager.should_show_strategy.return_value = False
         mock.return_value = manager
         yield manager
 
@@ -198,6 +199,43 @@ def test_mcp_update_task_dependencies(monkeypatch):
     assert called == [("task-one", "task-two,task-three")]
 
 
+def test_mcp_get_strategy(mock_manager):
+    mock_manager.get_strategy.return_value = None
+    assert mcp.get_strategy() == "No strategy defined yet."
+
+    mock_manager.get_strategy.return_value = (
+        "# Core Strategy\n<!-- comment -->\nFocus on quality."
+    )
+    assert mcp.get_strategy() == "# Core Strategy\nFocus on quality."
+
+
+def test_mcp_list_tasks_with_strategy(mock_manager):
+    mock_manager.sync_mission.return_value = [
+        Issue(name="Task 1", slug="task-1", status="pending", priority=1)
+    ]
+    mock_manager.should_show_strategy.return_value = True
+    mock_manager.get_strategy.return_value = (
+        "# Core Strategy\n<!-- comment -->\nFocus on quality."
+    )
+
+    result = mcp.list_tasks()
+    assert "> 📐 **Core Strategy**" in result
+    assert "> Focus on quality." in result
+    assert "[1] PENDING: Task 1" in result
+    mock_manager.update_strategy_last_shown.assert_called_once()
+
+
+def test_mcp_list_tasks_without_strategy(mock_manager):
+    mock_manager.sync_mission.return_value = [
+        Issue(name="Task 1", slug="task-1", status="pending", priority=1)
+    ]
+    mock_manager.should_show_strategy.return_value = False
+
+    result = mcp.list_tasks()
+    assert "> 📐" not in result
+    assert "[1] PENDING: Task 1" in result
+
+
 EXPECTED_TOOLS = {
     "list_tasks",
     "list_active_tasks",
@@ -213,6 +251,7 @@ EXPECTED_TOOLS = {
     "update_task_dependencies",
     "commit_repo",
     "commit_tasks",
+    "get_strategy",
 }
 
 

{task_agent-0.1.321 → task_agent-0.1.342}/uv.lock

@@ -1080,7 +1080,7 @@ wheels = [
 
 [[package]]
 name = "task-agent"
-version = "0.1.321"
+version = "0.1.342"
 source = { editable = "." }
 dependencies = [
     { name = "githubkit" },