amauta-ai 1.0.17

AMAUTA: Autonomous Modular Agent for Unified Task Assistance

AMAUTA: Autonomous Modular Agent for Unified Task Assistance

AMAUTA is a powerful command-line interface designed to streamline AI-powered software development. It integrates task management, code analysis, AI assistance, and more into a unified workflow. AMAUTA helps you organize your projects, leverage AI for code generation and analysis, and enforce development standards.

📋 Table of Contents

• Key Features
• Research-Plan-Execute-Test-Document Workflow
• Installation
• Quick Start
• AI Provider System
• Complete Command Reference
  • Core Commands
  • Task Management Commands
  • MCP Commands
  • Configuration Commands
  • Template Commands
  • Global Options
• Documentation
• Configuration
• Contributing
• License

✨ Key Features

• Unified Command Center: Access all development tools from a single CLI
• AI-Powered Intelligence:
  • Multi-Provider AI Integration:
    • Anthropic Claude for code generation and complex reasoning
    • Perplexity for research and up-to-date information
    • Intelligent provider selection based on operation type
  • Enhanced Research Mode: Global --research flag prioritizes Perplexity for knowledge-intensive tasks
• Advanced Task Management:
  • Hierarchical organization (Epics, Tasks, Stories, Issues)
  • AI-powered task creation, expansion, and complexity analysis
  • Detailed manual task creation with comprehensive workflow support
  • Dependency tracking and cascading updates
  • Dot notation for easy task referencing
• Comprehensive Code Analysis:
  • Codebase structure and complexity metrics
  • Visualization generation
  • Security scanning
  • Architecture recommendations
• Cursor IDE Integration:
  • Generate custom rules files
  • Model Control Protocol (MCP) server for enhanced context
• Offline-First Design:
  • All commands work in offline mode with basic functionality
  • Enhanced features when AI providers are available
  • Detailed manual task creation in offline mode

🔄 Research-Plan-Execute-Test-Document Workflow

AMAUTA's core philosophy is built around the comprehensive Research-Plan-Execute-Test-Document workflow that guides all development tasks:

1. Research: Gather information, context, and best practices before beginning work

   • Understand requirements and constraints
   • Explore existing solutions and approaches
   • Identify potential challenges and dependencies

2. Plan: Create a detailed implementation strategy based on research

   • Design the technical approach and architecture
   • Create timeline and milestones
   • Anticipate potential issues and prepare contingencies

3. Execute: Implement the solution following established standards

   • Write clean, maintainable code
   • Follow project coding standards
   • Address edge cases and error handling

4. Test: Verify the implementation works as expected

   • Create comprehensive test coverage
   • Validate against requirements
   • Ensure performance and security

5. Document: Create clear documentation for users and developers

   • Document implementation details
   • Create user guides as needed
   • Update project documentation

This workflow is integrated throughout AMAUTA's task management, audit, and code generation features. When tasks are created or expanded, they automatically follow this workflow to ensure comprehensive, high-quality implementations.

🚀 Installation

AMAUTA requires Python 3.10 or higher. The recommended way to install is via pipx:

Pipx Installation (Recommended)

pipx creates an isolated environment for the application and its dependencies:

# Install pipx if you haven't already
pip install --user pipx
pipx ensurepath

# Install AMAUTA (currently version 1.0.13)
pipx install amauta-ai

# Add AI provider dependencies
pipx inject amauta-ai "perplexipy>=1.2.0"  # For Perplexity AI integration
pipx inject amauta-ai "anthropic>=0.49.0"  # For Anthropic/Claude integration

# Verify installation
amauta --version

Pip Installation

Alternatively, you can install via pip:

pip install amauta-ai

Virtual Environment

# Create and activate a virtual environment
python -m venv amauta-env
source amauta-env/bin/activate  # On Windows: amauta-env\Scripts\activate

# Install AMAUTA
pip install amauta-ai

# Install AI provider dependencies
pip install "perplexipy>=1.2.0" "anthropic>=0.49.0"

# Verify installation
amauta --version

AI Provider Configuration

To enable AI-powered features, you'll need to configure API keys:

1. Create API Keys:

   • Anthropic API Key for Claude
   • Perplexity API Key for Perplexity

2. Set Environment Variables:

   • Create a .env file in your project root (or copy from .env.example)
   • Add your API keys:

   ANTHROPIC_API_KEY=your_anthropic_key_here
   PERPLEXITY_API_KEY=your_perplexity_key_here
   

Note: AMAUTA operates in offline mode with reduced functionality if API keys are unavailable.

For detailed installation options, see the Installation Guide.

Troubleshooting

Common Issues with AI Providers

1. Provider Not Available Errors:

   If you see errors like Explicitly selected provider perplexity is not available, make sure you've installed the required packages:

   # For pipx installations
   pipx inject amauta-ai "perplexipy>=1.2.0"  # For Perplexity
   pipx inject amauta-ai "anthropic>=0.49.0"  # For Anthropic/Claude
   
   # For pip installations
   pip install "perplexipy>=1.2.0" "anthropic>=0.49.0"
   

2. Request Timeout Errors:

   If you encounter timeout errors with large PRD files, try:

   • Using the --num-tasks option to reduce the number of tasks to generate
   • Ensuring your API credentials are valid and have sufficient quota
   • Updating to the latest version of AMAUTA (pip install --upgrade amauta-ai)

3. API Authentication Errors:

   Ensure your API keys are correctly set in your .env file or as environment variables:

   ANTHROPIC_API_KEY=your_anthropic_key_here
   PERPLEXITY_API_KEY=your_perplexity_key_here
   

🚦 Quick Start

# Initialize AMAUTA in your project
cd your-project
amauta init

# Configure API keys
cp .env.example .env
# Edit .env to add your API keys

# Create a high-level task (Epic)
amauta task add --type=Epic --prompt="Build authentication system with JWT and social login"

# List tasks to find the Epic ID
amauta task list

# Expand the Epic into subtasks (with research)
amauta task expand --id=EPIC-ID --research

# Analyze your codebase
amauta analyze --research

# Get architectural recommendations
amauta recommend-architecture --research

# Get the next task to work on
amauta task next

# Create a detailed task manually with workflow sections
amauta task create --title="Implement User Authentication" \
    --description="Main description" \
    --research-notes="Research notes" \
    --plan-notes="Planning notes" \
    --execute-notes="Implementation details" \
    --test-notes="Testing strategy" \
    --documentation-notes="Documentation plans"

For a more comprehensive step-by-step guide, see our Quick Start Guide.

🧠 AI Provider System

AMAUTA features an intelligent multi-provider AI system that selects the optimal AI service for each operation:

Provider Strengths

• Anthropic (Claude): Excels at code generation, understanding existing codebases, complex reasoning, and task planning
• Perplexity: Excels at research, up-to-date information, best practices recommendations, and technology evaluations

Provider Selection Logic

AMAUTA intelligently selects providers with this priority:

1. Explicit user selection via --provider=NAME flag
2. Research mode selection via --research flag (prioritizes Perplexity)
3. Task-specific mapping from configuration
4. Default provider from configuration

Research Mode

Use the global --research flag with any command to leverage Perplexity's research capabilities:

# Standard analysis (Anthropic/Claude)
amauta analyze

# Research-enhanced analysis (Perplexity)
amauta analyze --research

# Research-backed technology evaluation
amauta tech-evaluation "GraphQL vs REST for mobile APIs" --research

For more details on AI provider configuration, see the AI Provider Configuration documentation.

📊 Complete Command Reference

AMAUTA provides a rich set of commands with numerous options to streamline your development workflow. Here's a comprehensive reference of all available commands.

Global Options

These options can be applied to any AMAUTA command:

--version, -v            Show version and exit
--research               Use research-optimized provider (Perplexity) for AI operations
--offline                Run in offline mode (limited AI capabilities)
--debug                  Enable debug mode for more verbose error output
--lazy-imports           Enable lazy imports for faster startup (experimental)
--provider TEXT          Explicitly select AI provider (anthropic, perplexity)
--install-completion     Install completion for the current shell
--show-completion        Show completion for the current shell, to copy it or customize the installation
--help                   Show this message and exit

Core Commands

init

Initialize AMAUTA in the current project directory.

amauta init [OPTIONS]

Options:
  --force          Force overwrite of existing files
  --help           Show this message and exit

analyze

Analyze the codebase and generate reports.

amauta analyze [OPTIONS] [PATH]

Arguments:
  PATH             Path to analyze. Defaults to current directory

Options:
  --output-dir TEXT                      Directory to store output reports
  --visualizations/--no-visualizations   Generate interactive visualizations [default: visualizations]
  --offline/--no-offline                 Run analysis in offline mode (no AI API calls) [default: no-offline]
  --no-cache/--no-no-cache               Disable caching of analysis results [default: no-no-cache]
  --no-parallel/--no-no-parallel         Disable parallel processing of files [default: no-no-parallel]
  --workers INTEGER                      Number of worker processes for parallel analysis
  --research/--no-research               Use research-optimized provider (Perplexity) for enhanced analysis [default: no-research]
  --provider TEXT                        Explicitly select AI provider (anthropic, perplexity)
  --use-ai/--no-use-ai                   Use AI assistance for framework detection. If not specified, automatically detects if AI is available [default: no-use-ai]
  --help                                 Show this message and exit

parse-prd

Parse a PRD (Product Requirements Document) and generate tasks.

amauta parse-prd [OPTIONS] FILE

Arguments:
  FILE             Path to the PRD file [required]

Options:
  --num-tasks INTEGER                    Number of tasks to generate [default: 10]
  --research/--no-research               Use research-optimized provider (Perplexity) for PRD analysis [default: no-research]
  --provider TEXT                        Explicitly select AI provider (anthropic, perplexity)
  --offline/--no-offline                 Use offline mode with limited AI capabilities [default: no-offline]
  --help                                 Show this message and exit

generate-rules

Generate .cursor rules based on analysis.

amauta generate-rules [OPTIONS]

Options:
  --help           Show this message and exit

report

Generate a comprehensive project report.

amauta report [OPTIONS]

Options:
  --format TEXT     Output format (md, html, json) [default: md]
  --output TEXT     Output file path
  --help            Show this message and exit

summarize

Generate a comprehensive summary of the repository in a single file.

amauta summarize [OPTIONS]

Options:
  --output TEXT                          Output file path [default: amauta_summary.md]
  --include-tasks/--no-include-tasks     Include tasks from tasks.json
  --include-rules/--no-include-rules     Include rules from .cursorrules
  --include-code/--no-include-code       Include core code structure
  --max-files INTEGER                    Maximum number of files to include when summarizing code [default: 50]
  --help                                 Show this message and exit

cursor

Generate Cursor rules for AI-assisted development.

amauta cursor [OPTIONS]

Options:
  --help           Show this message and exit

audit

Run an AI-powered comprehensive project audit.

amauta audit [OPTIONS]

Options:
  --offline/--no-offline                 Run audit in offline mode (limited AI capabilities) [default: no-offline]
  --verbose/--no-verbose                 Show detailed information [default: no-verbose]
  --research/--no-research               Use research-optimized provider (Perplexity) for enhanced analysis [default: no-research]
  --provider TEXT                        Explicitly select AI provider (anthropic, perplexity)
  --focus TEXT                           Focus areas for audit (comma-separated: security,performance,maintainability,documentation)
  --depth TEXT                           Depth of task generation (epics_tasks, epics_tasks_stories, or full) [default: full]
  --help                                 Show this message and exit

generate-code

Generate code for a specific task using AI.

amauta generate-code [OPTIONS] TASK_ID FILE_PATH

Arguments:
  TASK_ID         Task ID to generate code for [required]
  FILE_PATH       Path where the code should be saved [required]

Options:
  --language TEXT                        Programming language to use
  --force/--no-force                     Overwrite existing file if it exists
  --provider TEXT                        AI provider (anthropic, openai, perplexity)
  --help                                 Show this message and exit

completion

Generate shell completion script for AMAUTA.

amauta completion [OPTIONS] SHELL_TYPE

Arguments:
  SHELL_TYPE      Type of shell (bash, zsh, fish)

Options:
  --install        Install completion script to the appropriate location
  --help           Show this message and exit

recommend-architecture

Analyze codebase and recommend architecture improvements.

amauta recommend-architecture [OPTIONS] [PATH]

Arguments:
  PATH            Path to analyze. Defaults to current directory

Options:
  --output TEXT                          Output file for recommendations (markdown or json)
  --offline/--no-offline                 Run in offline mode (no AI API calls) [default: no-offline]
  --research/--no-research               Use research-optimized provider (Perplexity) for enhanced analysis [default: no-research]
  --provider TEXT                        Explicitly select AI provider (anthropic, perplexity)
  --detailed/--no-detailed               Include detailed analysis in the output [default: no-detailed]
  --help                                 Show this message and exit

Task Management Commands

task add

Add a new task with AI assistance.

amauta task add [OPTIONS]

Options:
  --prompt, -p TEXT                      Description of the task to create [required]
  --type TEXT                            Type of task to create (task, story, epic, issue) [default: task]
  --parent TEXT                          Parent item ID to attach this task to
  --priority TEXT                        Priority of the task (low, medium, high, critical) [default: medium]
  --research/--no-research               Use research-optimized provider (Perplexity) for task creation [default: no-research]
  --provider TEXT                        Explicitly select AI provider (anthropic, perplexity)
  --offline/--no-offline                 Use offline mode with limited AI capabilities [default: no-offline]
  --help                                 Show this message and exit

task create

Create a new task manually with detailed information.

amauta task create [OPTIONS]

Options:
  --title, -t TEXT                     Title of the task to create [required]
  --description, -d TEXT               Detailed description of the task [required]
  --type TEXT                          Type of task to create (task, story, epic, issue) [default: task]
  --parent TEXT                        Parent item ID to attach this task to
  --priority TEXT                      Priority of the task (low, medium, high, critical) [default: medium]
  --details TEXT                       Additional implementation details or context
  --test-strategy TEXT                 Testing strategy for this task
  --dependencies TEXT                  Comma-separated list of task IDs this task depends on
  --status TEXT                        Initial status of task (pending, in_progress, review, done) [default: pending]
  --research-notes TEXT                Research notes for the Research phase
  --plan-notes TEXT                    Planning notes for the Plan phase
  --execute-notes TEXT                 Implementation notes for the Execute phase
  --test-notes TEXT                    Testing notes for the Test phase
  --documentation-notes TEXT           Documentation notes for the Document phase
  --tags TEXT                          Comma-separated list of tags for this task
  --estimated-hours FLOAT              Estimated hours to complete this task
  --due-date TEXT                      Due date for this task (YYYY-MM-DD)
  --help                               Show this message and exit

task edit-details

Edit an existing task with detailed information.

amauta task edit-details [OPTIONS] ID

Arguments:
  ID              ID of the task to edit [required]

Options:
  --title, -t TEXT                     New title for the task
  --description, -d TEXT               New description for the task
  --priority TEXT                      New priority of the task (low, medium, high, critical)
  --status TEXT                        New status of task (pending, in_progress, review, done)
  --details TEXT                       Additional implementation details or context
  --test-strategy TEXT                 Testing strategy for this task
  --add-dependencies TEXT              Comma-separated list of task IDs to add as dependencies
  --remove-dependencies TEXT           Comma-separated list of task IDs to remove from dependencies
  --research-notes TEXT                Research notes for the Research phase
  --plan-notes TEXT                    Planning notes for the Plan phase
  --execute-notes TEXT                 Implementation notes for the Execute phase
  --test-notes TEXT                    Testing notes for the Test phase
  --documentation-notes TEXT           Documentation notes for the Document phase
  --estimated-hours FLOAT              Estimated hours to complete this task
  --due-date TEXT                      Due date for this task (YYYY-MM-DD)
  --add-tags TEXT                      Comma-separated list of tags to add
  --remove-tags TEXT                   Comma-separated list of tags to remove
  --help                               Show this message and exit

task expand

Expand a task into more detailed subtasks with AI assistance.

amauta task expand [OPTIONS] ID

Arguments:
  ID              ID of the task to expand into subtasks [required]

Options:
  --num, -n INTEGER                      Number of subtasks to generate [default: 3]
  --research/--no-research               Use research-optimized provider (Perplexity) for task expansion [default: no-research]
  --provider TEXT                        Explicitly select AI provider (anthropic, perplexity)
  --offline/--no-offline                 Use offline mode with limited AI capabilities [default: no-offline]
  --help                                 Show this message and exit

task list

List items (Epics, Tasks, Stories, Issues) with filtering, sorting, and grouping.

amauta task list [OPTIONS]

Options:
  --help           Show this message and exit

task show

Show detailed information about a specific item.

amauta task show [OPTIONS] ID

Arguments:
  ID              ID of the item to show [required]

Options:
  --help           Show this message and exit

task next

Suggest the next task(s) to work on.

amauta task next [OPTIONS]

Options:
  --help           Show this message and exit

task set-status

Set the status of an item.

amauta task set-status [OPTIONS] ID STATUS

Arguments:
  ID              ID of the item to update [required]
  STATUS          New status (todo, in_progress, review, done) [required]

Options:
  --help           Show this message and exit

task add-dependency

Add a dependency between two items.

amauta task add-dependency [OPTIONS] TASK_ID DEPENDS_ON_ID

Arguments:
  TASK_ID         ID of the task that depends on another [required]
  DEPENDS_ON_ID   ID of the task that must be completed first [required]

Options:
  --help           Show this message and exit

task remove-dependency

Remove a dependency between two items.

amauta task remove-dependency [OPTIONS] TASK_ID DEPENDS_ON_ID

Arguments:
  TASK_ID         ID of the task that depends on another [required]
  DEPENDS_ON_ID   ID of the task that must be completed first [required]

Options:
  --help           Show this message and exit

task validate-dependencies

Validate all task dependencies in the system.

amauta task validate-dependencies [OPTIONS]

Options:
  --help           Show this message and exit

task fix-dependencies

Suggest and apply fixes for dependency issues.

amauta task fix-dependencies [OPTIONS]

Options:
  --help           Show this message and exit

task analyze-complexity

Analyze the complexity of tasks using AI.

amauta task analyze-complexity [OPTIONS]

Options:
  --help           Show this message and exit

task status-report

Generate a report of task statuses.

amauta task status-report [OPTIONS]

Options:
  --help           Show this message and exit

task update

Update a task with AI assistance.

amauta task update [OPTIONS]

Options:
  --help           Show this message and exit

MCP Commands

mcp run

Run the MCP server for Cursor integration.

amauta mcp run [OPTIONS]

Options:
  --help           Show this message and exit

mcp version

Show the MCP protocol version supported by AMAUTA.

amauta mcp version [OPTIONS]

Options:
  --help           Show this message and exit

Configuration Commands

config set

Set configuration value.

amauta config set [OPTIONS] KEY VALUE

Arguments:
  KEY             Configuration key to set [required]
  VALUE           Value to set [required]

Options:
  --temp/--no-temp                       Set value temporarily (won't persist to config file) [default: no-temp]
  --help                                 Show this message and exit

config get

Get configuration value(s).

amauta config get [OPTIONS] [KEY]

Arguments:
  KEY             Configuration key to get

Options:
  --help           Show this message and exit

config init

Initialize a new configuration file.

amauta config init [OPTIONS]

Options:
  --help           Show this message and exit

config reset

Reset configuration to default values.

amauta config reset [OPTIONS]

Options:
  --help           Show this message and exit

config export

Export configuration to a file.

amauta config export [OPTIONS]

Options:
  --help           Show this message and exit

config import

Import configuration from a file.

amauta config import [OPTIONS]

Options:
  --help           Show this message and exit

config sources

Show all sources for a configuration value.

amauta config sources [OPTIONS]

Options:
  --help           Show this message and exit

Template Commands

template list

List all available task templates.

amauta template list [OPTIONS]

Options:
  --help           Show this message and exit

template show

Show details of a specific template.

amauta template show [OPTIONS] ID

Arguments:
  ID              ID of the template to show [required]

Options:
  --help           Show this message and exit

template create

Create a new task template.

amauta template create [OPTIONS]

Options:
  --help           Show this message and exit

template apply

Apply a template to create new task items.

amauta template apply [OPTIONS] TEMPLATE_ID

Arguments:
  TEMPLATE_ID     ID of the template to apply [required]

Options:
  --help           Show this message and exit

template delete

Delete a task template.

amauta template delete [OPTIONS] ID

Arguments:
  ID              ID of the template to delete [required]

Options:
  --help           Show this message and exit

📝 Task Management

AMAUTA provides a comprehensive task management system:

Hierarchical Task Structure

• Epics: High-level features or initiatives
• Tasks: Individual development tasks
• Stories: User-focused requirements
• Issues: Bugs or technical debt

Task Management Workflow

1. Create high-level Epics:

   # Create Epic for a major feature
   amauta task add --type=Epic --prompt="Build user authentication system with social login options"
   

2. Expand Epics into Tasks:

   # Find the Epic ID first
   amauta task list --type=Epic
   
   # Expand with research-enhanced capabilities (uses Perplexity + Anthropic)
   amauta task expand --id=EPIC-ID --research
   

3. Track task progress:

   # Start working on a task
   amauta task set-status TASK-ID "in-progress"
   
   # Complete a task
   amauta task set-status TASK-ID "done"
   
   # Mark an Epic and all its children as complete
   amauta task set-status EPIC-ID "done" --cascade
   

4. Manage task relationships:

   # Create a subtask
   amauta task add --type=Task --parent=PARENT-ID --title="Implement password reset"
   
   # Add a dependency (TASK-A depends on TASK-B)
   amauta task add-dependency TASK-A TASK-B
   
   # Validate the dependency graph
   amauta task validate-dependencies
   

5. Update task details:

   # Update a single task
   amauta task update TASK-ID --priority=high --description="Updated description"
   
   # Update a task and propagate changes to related tasks
   amauta task update-cascade TASK-ID --prompt="Switch from JWT to session-based auth"
   

6. Create detailed tasks manually:

   # Create a task with structured workflow sections
   amauta task create --title="Authentication System" --description="Main description" \
       --research-notes="Research findings here" \
       --plan-notes="Implementation plan" \
       --execute-notes="Code implementation details" \
       --test-notes="Testing strategy" \
       --documentation-notes="Documentation plan"
       
   # Add metadata and planning information
   amauta task create --title="API Development" \
       --estimated-hours=8 \
       --due-date="2025-05-15" \
       --tags="backend,api,security"
   

For more task management commands and examples, see the Task Management documentation.

📚 Documentation

AMAUTA provides comprehensive documentation:

• Quick Start Guide - Get up and running in minutes
• Enhanced Documentation - Detailed guide to all features
• Best Practices - Recommended usage patterns
• Workflow Patterns - Common workflows

You can also access help directly from the command line:

# General help
amauta --help

# Command-specific help
amauta analyze --help
amauta task add --help
amauta task create --help

⚙️ Configuration

AMAUTA is configured via several mechanisms:

Configuration Files

• .amautarc.yaml: Main configuration file (created by amauta init)
• .env: Environment variables file for API keys and secrets
• tasks.json: Task storage file (managed by AMAUTA)

AI Provider Configuration

The .amautarc.yaml file contains settings for AI providers:

ai:
  anthropic:
    provider: "anthropic"
    default_model: "claude-3-5-sonnet-latest"
    api_key_env_var: "ANTHROPIC_API_KEY"
    version: "0.49.0+"
    capabilities:
      - "general"
      - "code"
      - "task"
      - "analysis"
  
  perplexipy:
    provider: "perplexipy"
    default_model: "sonar-medium-online"
    api_key_env_var: "PERPLEXITY_API_KEY"
    version: "1.2.0+"
    capabilities:
      - "research"
      - "general"
      - "code"

provider_preferences:
  general: ["anthropic", "perplexipy"]
  research: ["perplexipy", "anthropic"]
  code: ["anthropic", "perplexipy"]
  analysis: ["anthropic", "perplexipy"]
  task: ["anthropic", "perplexipy"]

Configuration Commands

# List all configuration settings
amauta config list

# Get a specific setting
amauta config get ai.anthropic.default_model

# Update a setting
amauta config set ai.perplexipy.default_model "sonar-medium-online"

# Reset configuration
amauta config reset

For detailed configuration options, see AI Provider Configuration.

👥 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

For major changes, please open an issue first to discuss what you would like to change.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

AMAUTA Unified AI Development Command Center

AMAUTA is a comprehensive command-line tool for AI-assisted development, including task management, code analysis, and documentation generation.

How to Publish to PyPI

Method 1: Using the publish.py script

1. Make sure your PyPI credentials are set:

   export TWINE_USERNAME="__token__"
   export TWINE_PASSWORD="your-pypi-token"
   

   (Or have PYPI_API_TOKEN in your .env file)

2. Run the publish script:

   python publish.py
   

Method 2: Manual publishing

1. Clean previous builds:

   rm -rf build/ dist/ *.egg-info/
   

2. Build the package:

   python -m pip install --upgrade build
   python -m build
   

3. Upload to PyPI:

   python -m pip install --upgrade twine
   python -m twine upload dist/*
   

Installation

pip install amauta-ai

Usage

amauta --help