tapps-agents 3.5.38__py3-none-any.whl → 3.5.40__py3-none-any.whl

tapps_agents/cli/commands/task.py

@@ -0,0 +1,219 @@
+"""
+Task management CLI: create, list, show, update, close, hydrate, dehydrate, run.
+
+Manages task specs in .tapps-agents/task-specs/ and sync with Beads (bd).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from ..feedback import get_feedback
+from .common import format_json_output
+
+
+def handle_task_command(args: object) -> None:
+    """Dispatch to task subcommand handler."""
+    cmd = getattr(args, "task_command", None)
+    if not cmd:
+        print("task: subcommand required (create, list, show, update, close, hydrate, dehydrate, run)", file=sys.stderr)
+        sys.exit(2)
+    handlers = {
+        "create": _handle_create,
+        "list": _handle_list,
+        "show": _handle_show,
+        "update": _handle_update,
+        "close": _handle_close,
+        "hydrate": _handle_hydrate,
+        "dehydrate": _handle_dehydrate,
+        "run": _handle_run,
+    }
+    handler = handlers.get(cmd)
+    if not handler:
+        print(f"task: unknown subcommand {cmd!r}", file=sys.stderr)
+        sys.exit(2)
+    handler(args)
+
+
+def _project_root() -> Path:
+    return Path.cwd()
+
+
+def _handle_create(args: object) -> None:
+    from ...beads.specs import TaskSpec, save_task_spec
+    from ...beads.hydration import hydrate_to_beads
+
+    task_id = getattr(args, "id", "").strip()
+    title = getattr(args, "title", "").strip()
+    if not task_id or not title:
+        print("task create: id and --title are required", file=sys.stderr)
+        sys.exit(2)
+    root = _project_root()
+    spec = TaskSpec(
+        id=task_id,
+        title=title,
+        description=getattr(args, "description", "") or "",
+        workflow=getattr(args, "workflow", "build") or "build",
+    )
+    save_task_spec(spec, root)
+    print(f"Created task spec: {spec.id} ({root / '.tapps-agents' / 'task-specs' / f'{spec.id}.yaml'})")
+    if getattr(args, "beads", False):
+        report = hydrate_to_beads(project_root=root)
+        if report.bd_unavailable:
+            print("Beads (bd) not available; spec created without Beads issue.", file=sys.stderr)
+        else:
+            print(f"Hydration: created={report.created}, skipped={report.skipped}")
+
+
+def _handle_list(args: object) -> None:
+    from ...beads.specs import load_task_specs
+
+    root = _project_root()
+    specs = load_task_specs(root)
+    status_filter = getattr(args, "status", None)
+    if status_filter:
+        specs = [s for s in specs if s.status == status_filter]
+    out_fmt = getattr(args, "format", "text")
+    if out_fmt == "json":
+        format_json_output([s.model_dump() for s in specs])
+        return
+    if not specs:
+        print("No task specs found.")
+        return
+    for s in specs:
+        beads = f" [bd:{s.beads_issue}]" if s.beads_issue else ""
+        print(f"  {s.id}  {s.status}  {s.title or ''}{beads}")
+
+
+def _handle_show(args: object) -> None:
+    from ...beads.specs import load_task_spec
+
+    task_id = getattr(args, "id", "").strip()
+    if not task_id:
+        print("task show: id required", file=sys.stderr)
+        sys.exit(2)
+    root = _project_root()
+    spec = load_task_spec(task_id, root)
+    if not spec:
+        print(f"Task not found: {task_id}", file=sys.stderr)
+        sys.exit(1)
+    print(f"id: {spec.id}")
+    print(f"title: {spec.title}")
+    print(f"status: {spec.status}")
+    print(f"workflow: {spec.workflow or 'build'}")
+    if spec.beads_issue:
+        print(f"beads_issue: {spec.beads_issue}")
+    if spec.description:
+        print(f"description: {spec.description}")
+
+
+def _handle_update(args: object) -> None:
+    from ...beads.specs import load_task_spec, save_task_spec
+
+    task_id = getattr(args, "id", "").strip()
+    status = getattr(args, "status", None)
+    if not task_id:
+        print("task update: id required", file=sys.stderr)
+        sys.exit(2)
+    if not status:
+        print("task update: --status required", file=sys.stderr)
+        sys.exit(2)
+    root = _project_root()
+    spec = load_task_spec(task_id, root)
+    if not spec:
+        print(f"Task not found: {task_id}", file=sys.stderr)
+        sys.exit(1)
+    spec = spec.model_copy(update={"status": status})
+    save_task_spec(spec, root)
+    print(f"Updated {task_id} status to {status}")
+
+
+def _handle_close(args: object) -> None:
+    from ...beads.specs import load_task_spec, save_task_spec
+
+    task_id = getattr(args, "id", "").strip()
+    if not task_id:
+        print("task close: id required", file=sys.stderr)
+        sys.exit(2)
+    root = _project_root()
+    spec = load_task_spec(task_id, root)
+    if not spec:
+        print(f"Task not found: {task_id}", file=sys.stderr)
+        sys.exit(1)
+    spec = spec.model_copy(update={"status": "done"})
+    save_task_spec(spec, root)
+    print(f"Closed {task_id}")
+
+
+def _handle_hydrate(args: object) -> None:
+    from ...beads.hydration import hydrate_to_beads
+
+    root = _project_root()
+    report = hydrate_to_beads(project_root=root)
+    if report.bd_unavailable:
+        print("Beads (bd) not available. Install to tools/bd or add bd to PATH.", file=sys.stderr)
+        sys.exit(1)
+    print(f"created={report.created} skipped={report.skipped} failed={report.failed} deps_added={report.deps_added}")
+
+
+def _handle_dehydrate(args: object) -> None:
+    from ...beads.hydration import dehydrate_from_beads
+
+    root = _project_root()
+    updated = dehydrate_from_beads(project_root=root)
+    print(f"Updated {updated} spec(s) from Beads.")
+
+
+def _handle_run(args: object) -> None:
+    from ...beads.specs import load_task_spec, save_task_spec
+
+    task_id = getattr(args, "id", "").strip()
+    if not task_id:
+        print("task run: id required", file=sys.stderr)
+        sys.exit(2)
+    root = _project_root()
+    spec = load_task_spec(task_id, root)
+    if not spec:
+        print(f"Task not found: {task_id}", file=sys.stderr)
+        sys.exit(1)
+    workflow_name = (spec.workflow or "build").strip().lower()
+    # Map task workflow name to preset
+    preset_map = {"build": "rapid", "fix": "fix", "review": "quality", "test": "quality", "full": "full"}
+    preset = preset_map.get(workflow_name, "rapid")
+    # Update spec to in-progress
+    spec = spec.model_copy(update={"status": "in-progress"})
+    save_task_spec(spec, root)
+    # Run workflow via CLI workflow path (simplified: invoke workflow preset)
+    try:
+        from ...workflow.executor import WorkflowExecutor
+        from ...workflow.preset_loader import PresetLoader
+        from ..base import run_async_command
+
+        loader = PresetLoader()
+        workflow = loader.load_preset(preset)
+        if not workflow:
+            print(f"Workflow preset not found: {preset}", file=sys.stderr)
+            spec = spec.model_copy(update={"status": "todo"})
+            save_task_spec(spec, root)
+            sys.exit(1)
+        executor = WorkflowExecutor(auto_detect=False, auto_mode=True)
+        executor.user_prompt = spec.title or spec.description or spec.id
+        target_file = (spec.files or [None])[0] if spec.files else None
+        final_state = run_async_command(
+            executor.execute(workflow=workflow, target_file=target_file)
+        )
+        if final_state.status == "completed":
+            spec = spec.model_copy(update={"status": "done"})
+            save_task_spec(spec, root)
+            print(f"Task {task_id} completed.")
+        else:
+            spec = spec.model_copy(update={"status": "todo"})
+            save_task_spec(spec, root)
+            print(f"Workflow ended with status: {final_state.status}", file=sys.stderr)
+            sys.exit(1)
+    except Exception as e:
+        spec = spec.model_copy(update={"status": "todo"})
+        save_task_spec(spec, root)
+        print(f"Error running workflow: {e}", file=sys.stderr)
+        sys.exit(1)

tapps_agents/cli/commands/top_level.py

@@ -1454,6 +1454,18 @@ def _print_init_results(results: dict[str, Any]) -> None:
         print("    - .cursorignore")
     else:
         print("  .cursorignore: Skipped or already exists")
+
+    if results.get("hooks"):
+        if results.get("hooks_templates"):
+            print("  Hooks: Created from templates (all disabled)")
+            print("    - .tapps-agents/hooks.yaml")
+            if results.get("context_created"):
+                print("    - .tapps-agents/context/")
+        else:
+            print("  Hooks: Minimal hooks.yaml created")
+            print("    - .tapps-agents/hooks.yaml")
+    else:
+        print("  Hooks: Skipped or already exists")
     
     # Show MCP config (will be shown in dedicated section)
     # MCP status is now shown in _print_mcp_status() function
@@ -2194,6 +2206,7 @@ def handle_init_command(args: object) -> None:
         backup_before_reset=not getattr(args, "no_backup", False),
         reset_mcp=getattr(args, "reset_mcp", False),
         preserve_custom=getattr(args, "preserve_custom", True),
+        include_hooks_templates=getattr(args, "hooks", False),
     )
     
     # Offer interactive Context7 setup if API key is missing

tapps_agents/cli/main.py

@@ -36,6 +36,7 @@ except (ImportError, AttributeError):
 from .commands import (
     analyst,
     architect,
+    cleanup_agent,
     debugger,
     designer,
     documenter,
@@ -50,6 +51,7 @@ from .commands import (
     planner,
     reviewer,
     simple_mode,
+    task as task_cmd,
     tester,
     top_level,
 )
@@ -59,6 +61,9 @@ from .feedback import FeedbackManager, ProgressMode, VerbosityLevel
 from .parsers import (
     analyst as analyst_parsers,
 )
+from .parsers import (
+    cleanup_agent as cleanup_agent_parsers,
+)
 from .parsers import (
     architect as architect_parsers,
 )
@@ -307,6 +312,7 @@ def register_all_parsers(parser: argparse.ArgumentParser) -> None:
     ops_parsers.add_ops_parser(subparsers)
     enhancer_parsers.add_enhancer_parser(subparsers)
     evaluator_parsers.add_evaluator_parser(subparsers)
+    cleanup_agent_parsers.add_cleanup_agent_parser(subparsers)
 
     # Register top-level parsers
     top_level_parsers.add_top_level_parsers(subparsers)
@@ -334,6 +340,7 @@ def _get_agent_command_handlers() -> dict[str, Callable[[argparse.Namespace], No
         "ops": ops.handle_ops_command,
         "enhancer": enhancer.handle_enhancer_command,
         "evaluator": evaluator.handle_evaluator_command,
+        "cleanup-agent": cleanup_agent.handle_cleanup_agent_command,
     }
 
 
@@ -361,6 +368,7 @@ def _get_top_level_command_handlers() -> dict[str, Callable[[argparse.Namespace]
         "setup-experts": top_level.handle_setup_experts_command,
         "cursor": top_level.handle_cursor_command,
         "beads": top_level.handle_beads_command,
+        "task": task_cmd.handle_task_command,
         "continuous-bug-fix": top_level.handle_continuous_bug_fix_command,
         "bug-fix-continuous": top_level.handle_continuous_bug_fix_command,
         "brownfield": top_level.handle_brownfield_command,
@@ -492,14 +500,19 @@ def route_command(args: argparse.Namespace) -> None:
         args = enhance_prompt_if_needed(args, config.auto_enhancement)
     
     agent = args.agent
-    
+
     # Handle None case (show help)
     if agent is None:
         help_parser = create_root_parser()
         register_all_parsers(help_parser)
         _safe_print_help(help_parser)
         return
-    
+
+    # Session lifecycle: start on first CLI command, SessionEnd via atexit
+    from pathlib import Path
+    from ..session import ensure_session_started
+    ensure_session_started(Path.cwd())
+
     # Try agent command handlers first
     agent_handlers = _get_agent_command_handlers()
     if agent in agent_handlers:

tapps_agents/cli/parsers/cleanup_agent.py

@@ -0,0 +1,228 @@
+"""
+Cleanup Agent parser definitions
+"""
+import argparse
+
+
+def add_cleanup_agent_parser(subparsers: argparse._SubParsersAction) -> None:
+    """Add cleanup-agent parser and subparsers."""
+    cleanup_agent_parser = subparsers.add_parser(
+        "cleanup-agent",
+        help="Project Cleanup Agent commands",
+        description="""Project structure analysis and intelligent cleanup agent.
+
+The Cleanup Agent helps keep projects clean by:
+  - Analyzing project structure for cleanup opportunities
+  - Detecting duplicate files and content
+  - Identifying outdated documentation
+  - Enforcing naming conventions (kebab-case)
+  - Generating cleanup plans with rationale
+  - Executing cleanup operations safely with backups
+
+Use this agent for guided project and docs cleanup after heavy development.""",
+    )
+    cleanup_subparsers = cleanup_agent_parser.add_subparsers(
+        dest="command",
+        help="Cleanup agent subcommand (use 'help' to see all available commands)",
+    )
+
+    # Analyze command
+    analyze_parser = cleanup_subparsers.add_parser(
+        "analyze",
+        aliases=["*analyze"],
+        help="Analyze project structure for cleanup opportunities",
+        description="""Analyze project structure to identify cleanup opportunities.
+
+Scans the specified path and detects:
+  - Duplicate files (by content hash)
+  - Outdated files (not modified in 90+ days)
+  - Naming convention violations
+  - Files with no references
+
+Example:
+  tapps-agents cleanup-agent analyze --path ./docs --pattern "*.md"
+  tapps-agents cleanup-agent analyze --output analysis.json""",
+    )
+    analyze_parser.add_argument(
+        "--path",
+        help="Path to analyze (defaults to ./docs). Can be any directory in the project.",
+    )
+    analyze_parser.add_argument(
+        "--pattern",
+        default="*.md",
+        help="File pattern to match (default: *.md). Supports glob patterns.",
+    )
+    analyze_parser.add_argument(
+        "--output",
+        help="Output file for analysis report (JSON format). If not specified, displays summary.",
+    )
+    analyze_parser.add_argument(
+        "--format",
+        choices=["json", "text", "markdown"],
+        default="json",
+        help="Output format: 'json' for structured data (default), 'text' for human-readable, 'markdown' for markdown",
+    )
+
+    # Plan command
+    plan_parser = cleanup_subparsers.add_parser(
+        "plan",
+        aliases=["*plan"],
+        help="Generate cleanup plan from analysis",
+        description="""Generate a cleanup plan with prioritized actions.
+
+Creates a plan based on analysis that includes:
+  - File categorization (keep, archive, delete, merge, rename)
+  - Priority levels (high, medium, low)
+  - Safety levels (safe, moderate, risky)
+  - Rationale for each action
+  - Estimated space savings
+
+Example:
+  tapps-agents cleanup-agent plan --analysis-file analysis.json
+  tapps-agents cleanup-agent plan --path ./docs --output cleanup-plan.json""",
+    )
+    plan_parser.add_argument(
+        "--analysis-file",
+        help="Path to analysis report JSON. If not provided, runs fresh analysis.",
+    )
+    plan_parser.add_argument(
+        "--path",
+        help="Path to analyze if no analysis file provided (defaults to ./docs).",
+    )
+    plan_parser.add_argument(
+        "--pattern",
+        default="*.md",
+        help="File pattern if running fresh analysis (default: *.md).",
+    )
+    plan_parser.add_argument(
+        "--output",
+        help="Output file for cleanup plan (JSON format).",
+    )
+    plan_parser.add_argument(
+        "--format",
+        choices=["json", "text", "markdown"],
+        default="json",
+        help="Output format (default: json).",
+    )
+
+    # Execute command
+    execute_parser = cleanup_subparsers.add_parser(
+        "execute",
+        aliases=["*execute"],
+        help="Execute cleanup plan (dry-run by default)",
+        description="""Execute cleanup operations from a plan.
+
+Performs cleanup actions with safety measures:
+  - Dry-run mode by default (preview changes)
+  - Optional backup creation before execution
+  - Reference updating for renamed/moved files
+  - Transaction logging for rollback capability
+
+Example:
+  tapps-agents cleanup-agent execute --plan-file cleanup-plan.json --dry-run
+  tapps-agents cleanup-agent execute --plan-file cleanup-plan.json --no-dry-run --backup""",
+    )
+    execute_parser.add_argument(
+        "--plan-file",
+        help="Path to cleanup plan JSON. If not provided, generates plan from analysis.",
+    )
+    execute_parser.add_argument(
+        "--path",
+        help="Path to analyze if no plan file provided (defaults to ./docs).",
+    )
+    execute_parser.add_argument(
+        "--pattern",
+        default="*.md",
+        help="File pattern if running fresh (default: *.md).",
+    )
+    execute_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        default=True,
+        help="Preview changes without executing (default: True).",
+    )
+    execute_parser.add_argument(
+        "--no-dry-run",
+        action="store_true",
+        help="Execute changes for real (disables dry-run).",
+    )
+    execute_parser.add_argument(
+        "--backup",
+        action="store_true",
+        default=True,
+        help="Create backup before execution (default: True).",
+    )
+    execute_parser.add_argument(
+        "--no-backup",
+        action="store_true",
+        help="Skip backup creation (not recommended).",
+    )
+    execute_parser.add_argument(
+        "--format",
+        choices=["json", "text", "markdown"],
+        default="json",
+        help="Output format (default: json).",
+    )
+
+    # Run command (full workflow)
+    run_parser = cleanup_subparsers.add_parser(
+        "run",
+        aliases=["*run"],
+        help="Run full cleanup workflow (analyze, plan, execute)",
+        description="""Run the complete cleanup workflow in one command.
+
+Executes all steps:
+  1. Analyze project structure
+  2. Generate cleanup plan
+  3. Execute cleanup operations
+
+By default runs in dry-run mode with backups enabled.
+
+Example:
+  tapps-agents cleanup-agent run --path ./docs --dry-run
+  tapps-agents cleanup-agent run --path ./docs --no-dry-run --backup""",
+    )
+    run_parser.add_argument(
+        "--path",
+        help="Path to analyze (defaults to ./docs).",
+    )
+    run_parser.add_argument(
+        "--pattern",
+        default="*.md",
+        help="File pattern to match (default: *.md).",
+    )
+    run_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        default=True,
+        help="Preview changes without executing (default: True).",
+    )
+    run_parser.add_argument(
+        "--no-dry-run",
+        action="store_true",
+        help="Execute changes for real (disables dry-run).",
+    )
+    run_parser.add_argument(
+        "--backup",
+        action="store_true",
+        default=True,
+        help="Create backup before execution (default: True).",
+    )
+    run_parser.add_argument(
+        "--no-backup",
+        action="store_true",
+        help="Skip backup creation (not recommended).",
+    )
+    run_parser.add_argument(
+        "--format",
+        choices=["json", "text", "markdown"],
+        default="json",
+        help="Output format (default: json).",
+    )
+
+    # Help command
+    cleanup_subparsers.add_parser(
+        "help",
+        aliases=["*help"],
+        help="Show cleanup agent commands",
+    )