attune-ai 2.0.0__py3-none-any.whl

attune/cli/parsers/batch.py

@@ -0,0 +1,118 @@
+"""Argument parser for batch processing commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def register_parsers(subparsers):
+    """Register batch command parsers.
+
+    Args:
+        subparsers: Subparser object from main argument parser
+
+    Returns:
+        None: Adds batch subparser with submit, status, results, wait subcommands
+    """
+    from ..commands.batch import (
+        cmd_batch_results,
+        cmd_batch_status,
+        cmd_batch_submit,
+        cmd_batch_wait,
+    )
+
+    # Main batch command
+    batch_parser = subparsers.add_parser(
+        "batch",
+        help="Batch processing via Anthropic Batch API (50% cost savings)",
+        description="Submit and manage batch processing jobs for non-urgent tasks",
+    )
+
+    # Batch subcommands
+    batch_subparsers = batch_parser.add_subparsers(dest="batch_command", required=True)
+
+    # batch submit command
+    submit_parser = batch_subparsers.add_parser(
+        "submit",
+        help="Submit a batch processing job from JSON file",
+        description="Submit batch requests for asynchronous processing (50% cost savings)",
+    )
+
+    submit_parser.add_argument(
+        "input_file",
+        help='JSON file with batch requests. Format: [{"task_id": "...", "task_type": "...", "input_data": {...}}]',
+    )
+
+    submit_parser.set_defaults(func=cmd_batch_submit)
+
+    # batch status command
+    status_parser = batch_subparsers.add_parser(
+        "status",
+        help="Check status of a batch processing job",
+        description="Display current status and request counts for a batch",
+    )
+
+    status_parser.add_argument(
+        "batch_id",
+        help="Batch ID (e.g., msgbatch_abc123)",
+    )
+
+    status_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output raw JSON status",
+    )
+
+    status_parser.set_defaults(func=cmd_batch_status)
+
+    # batch results command
+    results_parser = batch_subparsers.add_parser(
+        "results",
+        help="Retrieve results from completed batch",
+        description="Download and save batch results to JSON file",
+    )
+
+    results_parser.add_argument(
+        "batch_id",
+        help="Batch ID (e.g., msgbatch_abc123)",
+    )
+
+    results_parser.add_argument(
+        "output_file",
+        help="Path to output JSON file",
+    )
+
+    results_parser.set_defaults(func=cmd_batch_results)
+
+    # batch wait command
+    wait_parser = batch_subparsers.add_parser(
+        "wait",
+        help="Wait for batch to complete and retrieve results",
+        description="Poll batch status until completion, then download results",
+    )
+
+    wait_parser.add_argument(
+        "batch_id",
+        help="Batch ID (e.g., msgbatch_abc123)",
+    )
+
+    wait_parser.add_argument(
+        "output_file",
+        help="Path to output JSON file",
+    )
+
+    wait_parser.add_argument(
+        "--poll-interval",
+        type=int,
+        default=300,
+        help="Seconds between status checks (default: 300 = 5 minutes)",
+    )
+
+    wait_parser.add_argument(
+        "--timeout",
+        type=int,
+        default=86400,
+        help="Maximum wait time in seconds (default: 86400 = 24 hours)",
+    )
+
+    wait_parser.set_defaults(func=cmd_batch_wait)

attune/cli/parsers/cache.py

@@ -0,0 +1,65 @@
+"""Argument parser for cache commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def register_parsers(subparsers):
+    """Register cache command parsers.
+
+    Args:
+        subparsers: Subparser object from main argument parser
+
+    Returns:
+        None: Adds cache subparser with stats and clear subcommands
+    """
+    from ..commands.cache import cmd_cache_clear, cmd_cache_stats
+    # Main cache command
+    cache_parser = subparsers.add_parser(
+        "cache",
+        help="Cache monitoring and management",
+        description="Monitor prompt caching performance and cost savings",
+    )
+
+    # Cache subcommands
+    cache_subparsers = cache_parser.add_subparsers(dest="cache_command", required=True)
+
+    # cache stats command
+    stats_parser = cache_subparsers.add_parser(
+        "stats",
+        help="Show cache performance statistics",
+        description="Display prompt caching metrics including hit rate and cost savings",
+    )
+
+    stats_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    stats_parser.add_argument(
+        "--format",
+        choices=["table", "json"],
+        default="table",
+        help="Output format (default: table)",
+    )
+
+    stats_parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed token metrics",
+    )
+
+    stats_parser.set_defaults(func=cmd_cache_stats)
+
+    # cache clear command (placeholder)
+    clear_parser = cache_subparsers.add_parser(
+        "clear",
+        help="Clear cache (note: Anthropic cache is server-side with 5min TTL)",
+        description="Information about cache clearing",
+    )
+
+    clear_parser.set_defaults(func=cmd_cache_clear)

attune/cli/parsers/help.py

@@ -0,0 +1,41 @@
+"""Parser definitions for help commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import help as help_commands
+
+
+def register_parsers(subparsers):
+    """Register help command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object
+    """
+    # version command
+    parser_version = subparsers.add_parser("version", help="Display version information")
+    parser_version.set_defaults(func=help_commands.cmd_version)
+
+    # cheatsheet command
+    parser_cheatsheet = subparsers.add_parser("cheatsheet", help="Quick reference guide")
+    parser_cheatsheet.add_argument("--category", help="Specific category to show")
+    parser_cheatsheet.add_argument(
+        "--compact", action="store_true", help="Show commands only"
+    )
+    parser_cheatsheet.set_defaults(func=help_commands.cmd_cheatsheet)
+
+    # onboard command
+    parser_onboard = subparsers.add_parser("onboard", help="Interactive tutorial")
+    parser_onboard.add_argument("--step", type=int, help="Jump to specific step")
+    parser_onboard.add_argument("--reset", action="store_true", help="Reset progress")
+    parser_onboard.set_defaults(func=help_commands.cmd_onboard)
+
+    # explain command
+    parser_explain = subparsers.add_parser("explain", help="Explain a command in detail")
+    parser_explain.add_argument("command", help="Command to explain")
+    parser_explain.set_defaults(func=help_commands.cmd_explain)
+
+    # achievements command
+    parser_achievements = subparsers.add_parser("achievements", help="Show user progress")
+    parser_achievements.set_defaults(func=help_commands.cmd_achievements)

attune/cli/parsers/info.py

@@ -0,0 +1,26 @@
+"""Parser definitions for info commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import info as info_commands
+
+
+def register_parsers(subparsers):
+    """Register info command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object
+    """
+    # info command
+    parser_info = subparsers.add_parser("info", help="Display framework information")
+    parser_info.add_argument("--config", help="Path to config file")
+    parser_info.set_defaults(func=info_commands.cmd_info)
+
+    # frameworks command
+    parser_frameworks = subparsers.add_parser("frameworks", help="List agent frameworks")
+    parser_frameworks.add_argument("--all", action="store_true", help="Show all frameworks")
+    parser_frameworks.add_argument("--recommend", help="Recommend for use case")
+    parser_frameworks.add_argument("--json", action="store_true", help="Output as JSON")
+    parser_frameworks.set_defaults(func=info_commands.cmd_frameworks)

attune/cli/parsers/inspect.py

@@ -0,0 +1,66 @@
+"""Parser definitions for inspect commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import inspect
+
+
+def register_parsers(subparsers):
+    """Register inspect command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object from main parser
+    """
+    # Run command - Interactive REPL
+    parser_run = subparsers.add_parser("run", help="Interactive REPL mode")
+    parser_run.add_argument("--config", "-c", help="Configuration file path")
+    parser_run.add_argument("--user-id", help="User ID (default: cli_user)")
+    parser_run.add_argument(
+        "--level",
+        type=int,
+        default=4,
+        help="Target empathy level (1-5, default: 4)",
+    )
+    parser_run.set_defaults(func=inspect.cmd_run)
+
+    # Inspect command - Unified inspection
+    parser_inspect = subparsers.add_parser("inspect", help="Inspect patterns, metrics, or state")
+    parser_inspect.add_argument(
+        "type",
+        choices=["patterns", "metrics", "state"],
+        help="Type of inspection (patterns, metrics, or state)",
+    )
+    parser_inspect.add_argument("--user-id", help="User ID to filter by (optional)")
+    parser_inspect.add_argument("--db", help="Database path (default: .attune/patterns.db)")
+    parser_inspect.add_argument(
+        "--state-dir",
+        help="State directory path (default: .attune/state)",
+    )
+    parser_inspect.set_defaults(func=inspect.cmd_inspect)
+
+    # Export command
+    parser_export = subparsers.add_parser(
+        "export",
+        help="Export patterns to file for sharing/backup",
+    )
+    parser_export.add_argument("output", help="Output file path")
+    parser_export.add_argument(
+        "--user-id",
+        help="User ID to export (optional, exports all if not specified)",
+    )
+    parser_export.add_argument("--db", help="Database path (default: .attune/patterns.db)")
+    parser_export.add_argument(
+        "--format",
+        default="json",
+        choices=["json"],
+        help="Export format (default: json)",
+    )
+    parser_export.set_defaults(func=inspect.cmd_export)
+
+    # Import command
+    parser_import = subparsers.add_parser("import", help="Import patterns from file")
+    parser_import.add_argument("input", help="Input file path")
+    parser_import.add_argument("--db", help="Database path (default: .attune/patterns.db)")
+    parser_import.set_defaults(func=inspect.cmd_import)

attune/cli/parsers/metrics.py

@@ -0,0 +1,42 @@
+"""Parser definitions for metrics commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import metrics
+
+
+def register_parsers(subparsers):
+    """Register metrics command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object from main parser
+    """
+    # Metrics command
+    parser_metrics = subparsers.add_parser(
+        "metrics",
+        help="Display user metrics",
+    )
+    parser_metrics.add_argument(
+        "user",
+        help="User ID to retrieve metrics for",
+    )
+    parser_metrics.add_argument(
+        "--db",
+        default="./metrics.db",
+        help="Path to metrics database (default: ./metrics.db)",
+    )
+    parser_metrics.set_defaults(func=metrics.cmd_metrics_show)
+
+    # State command
+    parser_state = subparsers.add_parser(
+        "state",
+        help="List saved user states",
+    )
+    parser_state.add_argument(
+        "--state-dir",
+        default=".attune/state",
+        help="State directory path (default: .attune/state)",
+    )
+    parser_state.set_defaults(func=metrics.cmd_state_list)

attune/cli/parsers/orchestrate.py

@@ -0,0 +1,61 @@
+"""Parser definitions for orchestrate commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import orchestrate
+
+
+def register_parsers(subparsers):
+    """Register orchestrate command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object from main parser
+    """
+    # Orchestrate command
+    parser_orchestrate = subparsers.add_parser(
+        "orchestrate",
+        help="Run meta-orchestration workflows (release-prep, health-check)",
+    )
+    parser_orchestrate.add_argument(
+        "workflow",
+        choices=["release-prep", "health-check", "test-coverage"],
+        help="Orchestration workflow to run",
+    )
+    parser_orchestrate.add_argument(
+        "--path",
+        default=".",
+        help="Project path (for release-prep)",
+    )
+    parser_orchestrate.add_argument(
+        "--mode",
+        choices=["daily", "weekly", "release"],
+        help="Health check mode (for health-check)",
+    )
+    parser_orchestrate.add_argument(
+        "--project-root",
+        default=".",
+        help="Project root directory (for health-check)",
+    )
+    parser_orchestrate.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+    parser_orchestrate.add_argument(
+        "--min-coverage",
+        type=int,
+        help="Minimum test coverage percentage (for release-prep)",
+    )
+    parser_orchestrate.add_argument(
+        "--min-quality",
+        type=int,
+        help="Minimum quality score (for release-prep)",
+    )
+    parser_orchestrate.add_argument(
+        "--max-critical",
+        type=int,
+        help="Maximum critical issues allowed (for release-prep)",
+    )
+    parser_orchestrate.set_defaults(func=orchestrate.cmd_orchestrate)

attune/cli/parsers/patterns.py

@@ -0,0 +1,54 @@
+"""Parser definitions for pattern commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import patterns as patterns_commands
+
+
+def register_parsers(subparsers):
+    """Register pattern command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object
+    """
+    # Create patterns subcommand group
+    patterns_parser = subparsers.add_parser("patterns", help="Pattern management commands")
+    patterns_subparsers = patterns_parser.add_subparsers(dest="patterns_command")
+
+    # patterns list
+    parser_list = patterns_subparsers.add_parser("list", help="List patterns in library")
+    parser_list.add_argument("library", help="Path to pattern library")
+    parser_list.add_argument(
+        "--format", choices=["json", "sqlite"], default="json", help="Library format"
+    )
+    parser_list.set_defaults(func=patterns_commands.cmd_patterns_list)
+
+    # patterns export
+    parser_export = patterns_subparsers.add_parser("export", help="Export patterns")
+    parser_export.add_argument("input", help="Input file path")
+    parser_export.add_argument("output", help="Output file path")
+    parser_export.add_argument(
+        "--input-format", choices=["json", "sqlite"], default="json", help="Input format"
+    )
+    parser_export.add_argument(
+        "--output-format", choices=["json", "sqlite"], default="json", help="Output format"
+    )
+    parser_export.set_defaults(func=patterns_commands.cmd_patterns_export)
+
+    # patterns resolve
+    parser_resolve = patterns_subparsers.add_parser("resolve", help="Resolve a bug pattern")
+    parser_resolve.add_argument("bug_id", nargs="?", help="Bug ID to resolve")
+    parser_resolve.add_argument("--root-cause", help="Root cause description")
+    parser_resolve.add_argument("--fix", help="Fix description")
+    parser_resolve.add_argument("--fix-code", help="Code snippet of the fix")
+    parser_resolve.add_argument("--time", type=int, help="Resolution time in minutes")
+    parser_resolve.add_argument(
+        "--patterns-dir", default="./patterns", help="Patterns directory path"
+    )
+    parser_resolve.add_argument("--resolved-by", help="Who resolved it")
+    parser_resolve.add_argument(
+        "--no-regenerate", action="store_true", help="Don't regenerate summary"
+    )
+    parser_resolve.set_defaults(func=patterns_commands.cmd_patterns_resolve)

attune/cli/parsers/provider.py

@@ -0,0 +1,40 @@
+"""Parser definitions for provider commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import provider
+
+
+def register_parsers(subparsers):
+    """Register provider command parsers (Anthropic-only as of v5.0.0).
+
+    Args:
+        subparsers: ArgumentParser subparsers object from main parser
+    """
+    # Provider parent command
+    parser_provider = subparsers.add_parser(
+        "provider",
+        help="Configure Claude/Anthropic provider",
+    )
+    provider_sub = parser_provider.add_subparsers(dest="provider_command", required=True)
+
+    # Provider show command
+    p_show = provider_sub.add_parser(
+        "show",
+        help="Show current provider configuration",
+    )
+    p_show.set_defaults(func=provider.cmd_provider_show)
+
+    # Provider set command
+    p_set = provider_sub.add_parser(
+        "set",
+        help="Set default provider (must be 'anthropic')",
+    )
+    p_set.add_argument(
+        "name",
+        choices=["anthropic"],
+        help="Provider name (anthropic only)",
+    )
+    p_set.set_defaults(func=provider.cmd_provider_set)

attune/cli/parsers/routing.py

@@ -0,0 +1,110 @@
+"""Argument parser for adaptive routing commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def register_parsers(subparsers):
+    """Register routing command parsers.
+
+    Args:
+        subparsers: Subparser object from main argument parser
+
+    Returns:
+        None: Adds routing subparser with stats, check, models subcommands
+    """
+    from ..commands.routing import (
+        cmd_routing_check,
+        cmd_routing_models,
+        cmd_routing_stats,
+    )
+
+    # Main routing command
+    routing_parser = subparsers.add_parser(
+        "routing",
+        help="Adaptive model routing statistics and recommendations",
+        description="Analyze model routing performance based on historical telemetry",
+    )
+
+    # Routing subcommands
+    routing_subparsers = routing_parser.add_subparsers(
+        dest="routing_command", required=True
+    )
+
+    # routing stats command
+    stats_parser = routing_subparsers.add_parser(
+        "stats",
+        help="Show routing statistics for a workflow",
+        description="Display model performance metrics and recommendations",
+    )
+
+    stats_parser.add_argument("workflow", help="Workflow name (e.g., 'code-review')")
+
+    stats_parser.add_argument(
+        "--stage",
+        help="Stage name (optional, shows all stages if not specified)",
+    )
+
+    stats_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    stats_parser.set_defaults(func=cmd_routing_stats)
+
+    # routing check command
+    check_parser = routing_subparsers.add_parser(
+        "check",
+        help="Check for tier upgrade recommendations",
+        description="Analyze failure rates and recommend tier upgrades",
+    )
+
+    check_parser.add_argument(
+        "--workflow",
+        help="Workflow name (required unless --all is used)",
+    )
+
+    check_parser.add_argument(
+        "--stage",
+        help="Stage name (optional)",
+    )
+
+    check_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Check all workflows",
+    )
+
+    check_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    check_parser.set_defaults(func=cmd_routing_check)
+
+    # routing models command
+    models_parser = routing_subparsers.add_parser(
+        "models",
+        help="Compare model performance",
+        description="Show performance metrics for all models from a provider",
+    )
+
+    models_parser.add_argument(
+        "--provider",
+        default="anthropic",
+        help="Provider name (default: anthropic)",
+    )
+
+    models_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    models_parser.set_defaults(func=cmd_routing_models)

attune/cli/parsers/setup.py

@@ -0,0 +1,42 @@
+"""Parser definitions for setup commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..commands import setup
+
+
+def register_parsers(subparsers):
+    """Register setup command parsers.
+
+    Args:
+        subparsers: ArgumentParser subparsers object from main parser
+    """
+    # Init command
+    parser_init = subparsers.add_parser(
+        "init",
+        help="Initialize a new Empathy Framework project",
+    )
+    parser_init.add_argument(
+        "--format",
+        choices=["yaml", "json"],
+        default="yaml",
+        help="Configuration format (default: yaml)",
+    )
+    parser_init.add_argument(
+        "--output",
+        help="Output file path (default: attune.config.{format})",
+    )
+    parser_init.set_defaults(func=setup.cmd_init)
+
+    # Validate command
+    parser_validate = subparsers.add_parser(
+        "validate",
+        help="Validate a configuration file",
+    )
+    parser_validate.add_argument(
+        "config",
+        help="Path to configuration file to validate",
+    )
+    parser_validate.set_defaults(func=setup.cmd_validate)