Taskfile.yml

version: '1'
name: llx
description: Minimal Taskfile
variables:
  APP_NAME: llx
environments:
  local:
    container_runtime: docker
    compose_command: docker compose
pipeline:
  python_version: "3.12"
  runner_image: ubuntu-latest
  branches: [main]
  cache: [~/.cache/pip]
  artifacts: [dist/]

  stages:
    - name: lint
      tasks: [lint]

    - name: test
      tasks: [test]

    - name: build
      tasks: [build]
      when: "branch:main"

tasks:
  install:
    desc: Install Python dependencies (editable) with uv if available
    cmds:
    - uv pip install -e ".[dev]" 2>/dev/null || pip install -e ".[dev]"

  install-dev:
    desc: Fast dev install - test + lint only (< 60s)
    cmds:
    - uv venv 2>/dev/null || python -m venv .venv
    - uv pip install -e ".[dev]" 2>/dev/null || .venv/bin/pip install -e ".[dev]"

  install-full:
    desc: Full dev install with CI tools and MCP (< 2 min)
    cmds:
    - uv venv 2>/dev/null || python -m venv .venv
    - uv pip install -e ".[dev-full]" 2>/dev/null || .venv/bin/pip install -e ".[dev-full]"

  install-ci:
    desc: CI install with all dependencies
    cmds:
    - uv pip install -e ".[all]" 2>/dev/null || pip install -e ".[all]"
  test:
    desc: Run pytest suite
    cmds:
    - .venv/bin/pytest -q 2>/dev/null || pytest -q
  lint:
    desc: Run ruff lint check
    cmds:
    - .venv/bin/ruff check . 2>/dev/null || ruff check .
  fmt:
    desc: Auto-format with ruff
    cmds:
    - .venv/bin/ruff format . 2>/dev/null || ruff format .
  build:
    desc: Build wheel + sdist
    cmds:
    - python -m build
  clean:
    desc: Remove build artefacts
    cmds:
    - rm -rf build/ dist/ *.egg-info
  up:
    desc: Start services via docker compose
    cmds:
    - docker compose up -d
  down:
    desc: Stop services
    cmds:
    - docker compose down
  logs:
    desc: Tail compose logs
    cmds:
    - docker compose logs -f
  ps:
    desc: Show running compose services
    cmds:
    - docker compose ps
  docker-build:
    desc: Build docker image
    cmds:
    - docker build -t llx:latest .
  help:
    desc: '[imported from Makefile] help'
    cmds:
    - "echo \"\U0001F680 llx Development Commands\""
    - echo "=========================="
    - echo ""
    - echo "Setup:"
    - echo "  install          Install llx in development mode"
    - echo "  install-tools    Install local development tools"
    - echo ""
    - echo "Development:"
    - echo "  dev              Start development Docker stack"
    - echo "  prod             Start production Docker stack"
    - echo "  test             Run tests"
    - echo "  lint             Run linting"
    - echo "  format           Format code"
    - echo ""
    - echo "Docker:"
    - echo "  docker-dev       Start development containers"
    - echo "  docker-prod      Start production containers"
    - echo "  docker-stop      Stop all containers"
    - echo "  docker-clean     Clean Docker resources"
    - echo "  docker-logs      Show logs"
    - echo ""
    - echo "Examples:"
    - echo "  examples-basic   Run basic example"
    - echo "  examples-docker  Run Docker example"
    - echo "  examples-proxy   Run proxy example"
    - echo ""
    - echo "Utilities:"
    - echo "  clean            Clean temporary files"
    - echo "  backup           Create backups"
    - echo "  doctor           Check system health"
  install-tools:
    desc: '[imported from Makefile] install-tools'
    cmds:
    - "echo \"\U0001F527 Installing local tools...\""
    - if command -v ollama > /dev/null 2>&1; then \
    - "echo \"\u2705 Ollama already installed\"; \\"
    - else \
    - "echo \"\U0001F4E6 Installing Ollama...\"; \\"
    - curl -fsSL https://ollama.ai/install.sh | sh; \
    - fi
    - if command -v redis-cli > /dev/null 2>&1; then \
    - "echo \"\u2705 Redis CLI already installed\"; \\"
    - else \
    - "echo \"\U0001F4E6 Installing Redis CLI...\"; \\"
    - if command -v apt-get > /dev/null 2>&1; then \
    - sudo apt-get update && sudo apt-get install -y redis-tools; \
    - elif command -v brew > /dev/null 2>&1; then \
    - brew install redis; \
    - else \
    - echo "Please install Redis CLI manually"; \
    - fi; \
    - fi
    - "echo \"\u2705 Tools installation completed!\""
  dev:
    desc: '[imported from Makefile] dev'
    cmds:
    - "echo \"\U0001F680 Starting development environment...\""
    - ./docker-manage.sh dev
  prod:
    desc: '[imported from Makefile] prod'
    cmds:
    - "echo \"\U0001F680 Starting production environment...\""
    - ./docker-manage.sh prod
  test-docker:
    desc: '[imported from Makefile] test-docker'
    cmds:
    - "echo \"\U0001F433 Running tests in Docker...\""
    - docker build -t llx-test .
    - docker run --rm llx-test .venv/bin/python -m pytest tests/ -v
  format:
    desc: '[imported from Makefile] format'
    cmds:
    - "echo \"\U0001F4DD Formatting code...\""
    - .venv/bin/python -m black llx/
    - .venv/bin/python -m isort llx/
  docker-dev:
    desc: '[imported from Makefile] docker-dev'
    cmds:
    - "echo \"\U0001F433 Starting development containers...\""
    - ./docker-manage.sh dev
  docker-prod:
    desc: '[imported from Makefile] docker-prod'
    cmds:
    - "echo \"\U0001F433 Starting production containers...\""
    - ./docker-manage.sh prod
  docker-stop:
    desc: '[imported from Makefile] docker-stop'
    cmds:
    - "echo \"\U0001F6D1 Stopping all containers...\""
    - ./docker-manage.sh stop
  docker-clean:
    desc: '[imported from Makefile] docker-clean'
    cmds:
    - "echo \"\U0001F9F9 Cleaning Docker resources...\""
    - ./docker-manage.sh clean
  docker-logs:
    desc: '[imported from Makefile] docker-logs'
    cmds:
    - "echo \"\U0001F4CB Showing logs...\""
    - ./docker-manage.sh logs dev
  docker-status:
    desc: '[imported from Makefile] docker-status'
    cmds:
    - "echo \"\U0001F4CA Container status...\""
    - ./docker-manage.sh status
  examples-basic:
    desc: '[imported from Makefile] examples-basic'
    cmds:
    - "echo \"\U0001F4DA Running basic example...\""
    - cd examples/basic && ./run.sh
  examples-proxy:
    desc: '[imported from Makefile] examples-proxy'
    cmds:
    - "echo \"\U0001F4DA Running proxy example...\""
    - cd examples/proxy && timeout 10s ./run.sh || echo "Proxy example completed (timeout
      expected)"
  examples-docker:
    desc: '[imported from Makefile] examples-docker'
    cmds:
    - "echo \"\U0001F4DA Running Docker example...\""
    - cd examples/docker && ./run.sh
  examples-multi:
    desc: '[imported from Makefile] examples-multi'
    cmds:
    - "echo \"\U0001F4DA Running multi-provider example...\""
    - cd examples/multi-provider && ./run.sh
  examples-local:
    desc: '[imported from Makefile] examples-local'
    cmds:
    - "echo \"\U0001F4DA Running local models example...\""
    - cd examples/local && ./run.sh
  examples-all:
    desc: '[imported from Makefile] examples-all'
    cmds:
    - "echo \"\U0001F4DA Running all examples...\""
    - $(MAKE) examples-basic
    - $(MAKE) examples-multi
    - $(MAKE) examples-local
    - $(MAKE) examples-docker
  doctor:
    desc: '[imported from Makefile] doctor'
    cmds:
    - "echo \"\U0001F50D System health check...\""
    - echo ""
    - echo "Python:"
    - "python --version || echo \"\u274C Python not found\""
    - echo ""
    - echo "Docker:"
    - "docker --version || echo \"\u274C Docker not found\""
    - "docker info > /dev/null 2>&1 && echo \"\u2705 Docker daemon running\" || echo\
      \ \"\u274C Docker daemon not running\""
    - echo ""
    - echo "Local Tools:"
    - "command -v ollama > /dev/null 2>&1 && echo \"\u2705 Ollama installed\" || echo\
      \ \"\u274C Ollama not installed\""
    - "ollama list > /dev/null 2>&1 && echo \"\u2705 Ollama running\" || echo \"\u274C\
      \ Ollama not running\""
    - "command -v redis-cli > /dev/null 2>&1 && echo \"\u2705 Redis CLI installed\"\
      \ || echo \"\u274C Redis CLI not installed\""
    - echo ""
    - echo "Virtual Environment:"
    - "test -d .venv && echo \"\u2705 .venv exists\" || echo \"\u274C .venv not found\""
    - "test -f .venv/bin/python && echo \"\u2705 Python in .venv\" || echo \"\u274C\
      \ Python not in .venv\""
    - echo ""
    - echo "Configuration Files:"
    - "test -f .env && echo \"\u2705 .env exists\" || echo \"\u274C .env not found\""
    - "test -f llx.yaml && echo \"\u2705 llx.yaml exists\" || echo \"\u274C llx.yaml\
      \ not found\""
    - "test -f litellm-config.yaml && echo \"\u2705 litellm-config.yaml exists\" ||\
      \ echo \"\u274C litellm-config.yaml not found\""
    - "test -f docker-compose.yml && echo \"\u2705 docker-compose.yml exists\" ||\
      \ echo \"\u274C docker-compose.yml not found\""
    - echo ""
    - echo "API Keys:"
    - "grep -q \"ANTHROPIC_API_KEY=\" .env && echo \"\u2705 ANTHROPIC_API_KEY configured\"\
      \ || echo \"\u274C ANTHROPIC_API_KEY not configured\""
    - "grep -q \"OPENROUTER_API_KEY=\" .env && echo \"\u2705 OPENROUTER_API_KEY configured\"\
      \ || echo \"\u274C OPENROUTER_API_KEY not configured\""
    - echo ""
    - echo "Docker Services:"
    - "docker ps --format \"table {{.Names}}\\t{{.Status}}\" | grep -E \"llx-|llx_\"\
      \ || echo \"\u274C No llx containers running\""
    - echo ""
    - echo "Local Ollama Models:"
    - "ollama list 2>/dev/null | head -5 || echo \"\u274C No local models\""
  backup:
    desc: '[imported from Makefile] backup'
    cmds:
    - "echo \"\U0001F4BE Creating backups...\""
    - ./docker-manage.sh backup
    - "echo \"\u2705 Backup completed!\""
  quick-test:
    desc: '[imported from Makefile] quick-test'
    cmds:
    - "echo \"\u26A1 Quick test...\""
    - ".venv/bin/python -c \"from llx import analyze_project, select_model; print('\u2705\
      \ llx imports working')\""
  quick-start:
    desc: '[imported from Makefile] quick-start'
    cmds:
    - "echo \"\u26A1 Quick start...\""
    - $(MAKE) install
    - $(MAKE) install-tools
    - $(MAKE) docker-dev
    - "echo \"\u2705 Quick start completed!\""
    - 'echo "Services: http://localhost:4000 (API), http://localhost:3000 (WebUI)"'
  ci-install:
    desc: '[imported from Makefile] ci-install'
    cmds:
    - "echo \"\U0001F527 CI installation...\""
    - python -m venv .venv
    - .venv/bin/pip install --upgrade pip
    - .venv/bin/pip install -e .
    - .venv/bin/pip install -r requirements-dev.txt
  ci-test:
    desc: '[imported from Makefile] ci-test'
    cmds:
    - "echo \"\U0001F9EA CI testing...\""
    - .venv/bin/python -m pytest tests/ -v --cov=llx --cov-report=xml --cov-report=html
  ci-lint:
    desc: '[imported from Makefile] ci-lint'
    cmds:
    - "echo \"\U0001F50D CI linting...\""
    - .venv/bin/python -m flake8 llx/ --max-line-length=100 --ignore=E203,W503 --output-format=github
    - .venv/bin/python -m mypy llx/ --ignore-missing-imports --junit-xml test-results.xml
  ci-build:
    desc: '[imported from Makefile] ci-build'
    cmds:
    - "echo \"\U0001F433 CI build...\""
    - docker build -t llx:${BUILD_NUMBER:-latest} .
    - docker tag llx:${BUILD_NUMBER:-latest} llx:latest
  version:
    desc: '[imported from Makefile] version'
    cmds:
    - "echo \"\U0001F4E6 Version information...\""
    - '.venv/bin/python -c "import llx; print(f''llx version: {llx.__version__}'')"'
  tag:
    desc: '[imported from Makefile] tag'
    cmds:
    - "echo \"\U0001F3F7\uFE0F  Creating git tag...\""
    - if [ -z "$(VERSION)" ]; then \
    - 'echo "Usage: make tag VERSION=v1.0.0"; \'
    - exit 1; \
    - fi
    - git tag $(VERSION)
    - git push origin $(VERSION)
  docs:
    desc: '[imported from Makefile] docs'
    cmds:
    - "echo \"\U0001F4DA Building documentation...\""
    - .venv/bin/python -m mkdocs build
  docs-serve:
    desc: '[imported from Makefile] docs-serve'
    cmds:
    - "echo \"\U0001F4DA Serving documentation...\""
    - .venv/bin/python -m mkdocs serve
  profile:
    desc: '[imported from Makefile] profile'
    cmds:
    - "echo \"\U0001F4CA Running performance profile...\""
    - .venv/bin/python -m cProfile -o profile.stats -m llx analyze .
    - .venv/bin/python -c "import pstats; p = pstats.Stats('profile.stats'); p.sort_stats('cumulative');
      p.print_stats(20)"
  security:
    desc: '[imported from Makefile] security'
    cmds:
    - "echo \"\U0001F512 Running security scan...\""
    - .venv/bin/pip install safety bandit
    - .venv/bin/safety check
    - .venv/bin/bandit -r llx/
  db-reset:
    desc: '[imported from Makefile] db-reset'
    cmds:
    - "echo \"\U0001F5C4\uFE0F  Resetting database...\""
    - docker exec llx-postgres-prod psql -U llx -d llx -c "DROP SCHEMA IF EXISTS llx
      CASCADE; CREATE SCHEMA llx;"
    - docker exec llx-postgres-prod psql -U llx -d llx -f /docker-entrypoint-initdb.d/init.sql
  db-migrate:
    desc: '[imported from Makefile] db-migrate'
    cmds:
    - "echo \"\U0001F5C4\uFE0F  Running database migrations...\""
    - '# Add migration commands here'
  env-dev:
    desc: '[imported from Makefile] env-dev'
    cmds:
    - "echo \"\U0001F527 Setting up development environment...\""
    - cp .env.example .env.dev
    - "echo \"\u2705 Created .env.dev - please edit with your values\""
  env-prod:
    desc: '[imported from Makefile] env-prod'
    cmds:
    - "echo \"\U0001F527 Setting up production environment...\""
    - cp .env.example .env.prod
    - "echo \"\u2705 Created .env.prod - please edit with production values\""
  health:
    desc: '[from doql] workflow: health'
    cmds:
    - docker compose ps
    - docker compose exec app echo "Health check passed"
  import-makefile-hint:
    desc: '[from doql] workflow: import-makefile-hint'
    cmds:
    - 'echo ''Run: taskfile import Makefile to import existing targets.'''
  all:
    desc: Run install, lint, test
    cmds:
    - taskfile run install
    - taskfile run lint
    - taskfile run test
  sumd:
    desc: Generate SUMD (Structured Unified Markdown Descriptor) for AI-aware project description
    cmds:
    - |
      echo "# $(basename $(pwd))" > SUMD.md
      echo "" >> SUMD.md
      echo "$(python3 -c "import tomllib; f=open('pyproject.toml','rb'); d=tomllib.load(f); print(d.get('project',{}).get('description','Project description'))" 2>/dev/null || echo 'Project description')" >> SUMD.md
      echo "" >> SUMD.md
      echo "## Contents" >> SUMD.md
      echo "" >> SUMD.md
      echo "- [Metadata](#metadata)" >> SUMD.md
      echo "- [Architecture](#architecture)" >> SUMD.md
      echo "- [Dependencies](#dependencies)" >> SUMD.md
      echo "- [Source Map](#source-map)" >> SUMD.md
      echo "- [Intent](#intent)" >> SUMD.md
      echo "" >> SUMD.md
      echo "## Metadata" >> SUMD.md
      echo "" >> SUMD.md
      echo "- **name**: \`$(basename $(pwd))\`" >> SUMD.md
      echo "- **version**: \`$(python3 -c "import tomllib; f=open('pyproject.toml','rb'); d=tomllib.load(f); print(d.get('project',{}).get('version','unknown'))" 2>/dev/null || echo 'unknown')\`" >> SUMD.md
      echo "- **python_requires**: \`>=$(python3 --version 2>/dev/null | cut -d' ' -f2 | cut -d. -f1,2)\`" >> SUMD.md
      echo "- **license**: $(python3 -c "import tomllib; f=open('pyproject.toml','rb'); d=tomllib.load(f); print(d.get('project',{}).get('license',{}).get('text','MIT'))" 2>/dev/null || echo 'MIT')" >> SUMD.md
      echo "- **ecosystem**: SUMD + DOQL + testql + taskfile" >> SUMD.md
      echo "- **generated_from**: pyproject.toml, Taskfile.yml, Makefile, src/" >> SUMD.md
      echo "" >> SUMD.md
      echo "## Architecture" >> SUMD.md
      echo "" >> SUMD.md
      echo '```' >> SUMD.md
      echo "SUMD (description) → DOQL/source (code) → taskfile (automation) → testql (verification)" >> SUMD.md
      echo '```' >> SUMD.md
      echo "" >> SUMD.md
      echo "## Source Map" >> SUMD.md
      echo "" >> SUMD.md
      find . -name '*.py' -not -path './.venv/*' -not -path './venv/*' -not -path './__pycache__/*' -not -path './.git/*' | head -50 | sed 's|^./||' | sed 's|^|- |' >> SUMD.md
      echo "Generated SUMD.md"
    - |
      python3 -c "
      import json, os, subprocess
      from pathlib import Path
      project_name = Path.cwd().name
      py_files = list(Path('.').rglob('*.py'))
      py_files = [f for f in py_files if not any(x in str(f) for x in ['.venv', 'venv', '__pycache__', '.git'])]
      data = {
          'project_name': project_name,
          'description': 'SUMD - Structured Unified Markdown Descriptor for AI-aware project refactorization',
          'files': [{'path': str(f), 'type': 'python'} for f in py_files[:100]]
      }
      with open('sumd.json', 'w') as f:
          json.dump(data, f, indent=2)
      print('Generated sumd.json')
      " 2>/dev/null || echo 'Python generation failed, using fallback'
  sumr:
    desc: Generate SUMR (Summary Report) with project metrics and health status
    cmds:
    - |
      echo "# $(basename $(pwd)) - Summary Report" > SUMR.md
      echo "" >> SUMR.md
      echo "SUMR - Summary Report for project analysis" >> SUMR.md
      echo "" >> SUMR.md
      echo "## Contents" >> SUMR.md
      echo "" >> SUMR.md
      echo "- [Metadata](#metadata)" >> SUMR.md
      echo "- [Quality Status](#quality-status)" >> SUMR.md
      echo "- [Metrics](#metrics)" >> SUMR.md
      echo "- [Refactoring Analysis](#refactoring-analysis)" >> SUMR.md
      echo "- [Intent](#intent)" >> SUMR.md
      echo "" >> SUMR.md
      echo "## Metadata" >> SUMR.md
      echo "" >> SUMR.md
      echo "- **name**: \`$(basename $(pwd))\`" >> SUMR.md
      echo "- **version**: \`$(python3 -c "import tomllib; f=open('pyproject.toml','rb'); d=tomllib.load(f); print(d.get('project',{}).get('version','unknown'))" 2>/dev/null || echo 'unknown')\`" >> SUMR.md
      echo "- **generated_at**: \`$(date -Iseconds)\`" >> SUMR.md
      echo "" >> SUMR.md
      echo "## Quality Status" >> SUMR.md
      echo "" >> SUMR.md
      if [ -f pyqual.yaml ]; then
        echo "- **pyqual_config**: ✅ Present" >> SUMR.md
        echo "- **last_run**: $(stat -c %y .pyqual/pipeline.db 2>/dev/null | cut -d' ' -f1 || echo 'N/A')" >> SUMR.md
      else
        echo "- **pyqual_config**: ❌ Missing" >> SUMR.md
      fi
      echo "" >> SUMR.md
      echo "## Metrics" >> SUMR.md
      echo "" >> SUMR.md
      py_files=$(find . -name '*.py' -not -path './.venv/*' -not -path './venv/*' | wc -l)
      echo "- **python_files**: $py_files" >> SUMR.md
      lines=$(find . -name '*.py' -not -path './.venv/*' -not -path './venv/*' -exec cat {} \; 2>/dev/null | wc -l)
      echo "- **total_lines**: $lines" >> SUMR.md
      echo "" >> SUMR.md
      echo "## Refactoring Analysis" >> SUMR.md
      echo "" >> SUMR.md
      echo "Run \`code2llm ./ -f evolution\` for detailed refactoring queue." >> SUMR.md
      echo "Generated SUMR.md"
    - |
      python3 -c "
      import json, os, subprocess
      from pathlib import Path
      from datetime import datetime
      project_name = Path.cwd().name
      py_files = len([f for f in Path('.').rglob('*.py') if not any(x in str(f) for x in ['.venv', 'venv', '__pycache__', '.git'])])
      data = {
          'project_name': project_name,
          'report_type': 'SUMR',
          'generated_at': datetime.now().isoformat(),
          'metrics': {
              'python_files': py_files,
              'has_pyqual_config': Path('pyqual.yaml').exists()
          }
      }
      with open('SUMR.json', 'w') as f:
          json.dump(data, f, indent=2)
      print('Generated SUMR.json')
      " 2>/dev/null || echo 'Python generation failed, using fallback'