bpsai-pair 0.2.0__py3-none-any.whl

bpsai_pair/ops.py

@@ -0,0 +1,451 @@
+"""
+Operations module for cross-platform compatibility.
+Replaces shell scripts with Python implementations.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import tarfile
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional, Set
+import shutil
+import json
+
+
+class GitOps:
+    """Git operations helper."""
+    
+    @staticmethod
+    def is_repo(path: Path) -> bool:
+        """Check if path is a git repo."""
+        return (path / ".git").exists()
+    
+    @staticmethod
+    def is_clean(path: Path) -> bool:
+        """Check if working tree is clean."""
+        try:
+            # Check for unstaged changes
+            result = subprocess.run(
+                ["git", "diff", "--quiet"],
+                cwd=path,
+                capture_output=True
+            )
+            if result.returncode != 0:
+                return False
+
+            # Check for staged changes
+            staged = subprocess.run(
+                ["git", "diff", "--cached", "--quiet"],
+                cwd=path,
+                capture_output=True
+            )
+            if staged.returncode != 0:
+                return False
+
+            # Check for untracked files
+            untracked = subprocess.run(
+                ["git", "ls-files", "--other", "--exclude-standard"],
+                cwd=path,
+                capture_output=True,
+                text=True
+            )
+            if untracked.stdout.strip():
+                return False
+
+            return True
+        except:
+            return False
+    
+    @staticmethod
+    def current_branch(path: Path) -> str:
+        """Get current branch name."""
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=path,
+            capture_output=True,
+            text=True
+        )
+        return result.stdout.strip() if result.returncode == 0 else ""
+    
+    @staticmethod
+    def create_branch(path: Path, branch: str, from_branch: str = "main") -> bool:
+        """Create and checkout a new branch."""
+        # Check if source branch exists
+        check = subprocess.run(
+            ["git", "rev-parse", "--verify", from_branch],
+            cwd=path,
+            capture_output=True
+        )
+        if check.returncode != 0:
+            return False
+        
+        # Checkout source branch
+        subprocess.run(["git", "checkout", from_branch], cwd=path, capture_output=True)
+        
+        # Pull if upstream exists
+        upstream = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+            cwd=path,
+            capture_output=True
+        )
+        if upstream.returncode == 0:
+            subprocess.run(["git", "pull", "--ff-only"], cwd=path, capture_output=True)
+        
+        # Create new branch
+        result = subprocess.run(
+            ["git", "checkout", "-b", branch],
+            cwd=path,
+            capture_output=True
+        )
+        return result.returncode == 0
+    
+    @staticmethod
+    def add_commit(path: Path, files: List[Path], message: str) -> bool:
+        """Add files and commit."""
+        for f in files:
+            subprocess.run(["git", "add", str(f)], cwd=path, capture_output=True)
+        
+        result = subprocess.run(
+            ["git", "commit", "-m", message],
+            cwd=path,
+            capture_output=True
+        )
+        return result.returncode == 0
+
+
+class ProjectTree:
+    """Generate project tree snapshots."""
+    
+    @staticmethod
+    def generate(root: Path, excludes: Optional[Set[str]] = None) -> str:
+        """Generate a tree structure of the project."""
+        if excludes is None:
+            excludes = {
+                '.git', '.venv', 'venv', '__pycache__', 
+                'node_modules', 'dist', 'build', '.mypy_cache',
+                '.pytest_cache', '.tox', '*.egg-info', '.DS_Store'
+            }
+        
+        tree_lines = []
+        
+        def should_skip(path: Path) -> bool:
+            name = path.name
+            for pattern in excludes:
+                if pattern.startswith('*') and name.endswith(pattern[1:]):
+                    return True
+                if name == pattern:
+                    return True
+            return False
+        
+        def walk_dir(dir_path: Path, prefix: str = ""):
+            items = sorted(dir_path.iterdir(), key=lambda x: (x.is_file(), x.name))
+            items = [i for i in items if not should_skip(i)]
+            
+            for i, item in enumerate(items):
+                is_last = i == len(items) - 1
+                current = "└── " if is_last else "├── "
+                tree_lines.append(f"{prefix}{current}{item.name}")
+                
+                if item.is_dir():
+                    extension = "    " if is_last else "│   "
+                    walk_dir(item, prefix + extension)
+        
+        tree_lines.append(".")
+        walk_dir(root)
+        return "\n".join(tree_lines)
+
+
+class ContextPacker:
+    """Package context files for AI agents."""
+    
+    @staticmethod
+    def read_ignore_patterns(ignore_file: Path) -> Set[str]:
+        """Read patterns from .agentpackignore file."""
+        patterns = set()
+        if ignore_file.exists():
+            with open(ignore_file, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        patterns.add(line.rstrip('/'))
+        else:
+            # Default patterns
+            patterns = {
+                '.git', '.venv', '__pycache__', 'node_modules',
+                'dist', 'build', '*.log', '*.bak', '*.tgz', 
+                '*.tar.gz', '*.zip', '.env*'
+            }
+        return patterns
+    
+    @staticmethod
+    def should_exclude(path: Path, patterns: Set[str]) -> bool:
+        """Check if path should be excluded based on patterns."""
+        path_str = str(path).replace('\\', '/')
+        
+        for pattern in patterns:
+            # Handle wildcards
+            if '*' in pattern:
+                import fnmatch
+                if fnmatch.fnmatch(path.name, pattern):
+                    return True
+                if fnmatch.fnmatch(path_str, pattern):
+                    return True
+            # Handle directory patterns
+            elif pattern.endswith('/'):
+                if path.is_dir() and path.name == pattern[:-1]:
+                    return True
+            # Exact match
+            elif path.name == pattern:
+                return True
+            # Path contains pattern
+            elif pattern in path_str.split('/'):
+                return True
+        
+        return False
+    
+    @staticmethod
+    def pack(
+        root: Path,
+        output: Path,
+        extra_files: Optional[List[str]] = None,
+        dry_run: bool = False
+    ) -> List[Path]:
+        """Create a context pack for AI agents."""
+        # Default files to include
+        context_files = [
+            root / "context" / "development.md",
+            root / "context" / "agents.md", 
+            root / "context" / "project_tree.md",
+        ]
+        
+        # Add directory_notes if it exists
+        dir_notes = root / "context" / "directory_notes"
+        if dir_notes.exists():
+            for note in dir_notes.rglob("*.md"):
+                context_files.append(note)
+        
+        # Add extra files
+        if extra_files:
+            for extra in extra_files:
+                extra_path = root / extra
+                if extra_path.exists():
+                    context_files.append(extra_path)
+        
+        # Filter out non-existent files
+        context_files = [f for f in context_files if f.exists()]
+        
+        if dry_run:
+            return context_files
+        
+        # Read ignore patterns
+        ignore_file = root / ".agentpackignore"
+        patterns = ContextPacker.read_ignore_patterns(ignore_file)
+        
+        # Create tarball
+        with tarfile.open(output, "w:gz") as tar:
+            for file_path in context_files:
+                # Check if file should be excluded
+                if not ContextPacker.should_exclude(file_path, patterns):
+                    arcname = file_path.relative_to(root)
+                    tar.add(file_path, arcname=str(arcname))
+        
+        return context_files
+
+
+class FeatureOps:
+    """Operations for feature branch management."""
+    
+    @staticmethod
+    def create_feature(
+        root: Path,
+        name: str,
+        branch_type: str = "feature",
+        primary_goal: str = "",
+        phase: str = "",
+        force: bool = False
+    ) -> bool:
+        """Create a feature branch and update context."""
+        # Check if working tree is clean
+        if not force and not GitOps.is_clean(root):
+            raise ValueError("Working tree not clean. Commit or stash changes, or use --force")
+        
+        # Create branch
+        branch_name = f"{branch_type}/{name}"
+        if not GitOps.create_branch(root, branch_name):
+            raise ValueError(f"Failed to create branch {branch_name}")
+        
+        # Ensure context directory structure
+        context_dir = root / "context"
+        context_dir.mkdir(exist_ok=True)
+        (context_dir / "directory_notes").mkdir(exist_ok=True)
+        
+        # Update or create development.md
+        dev_file = context_dir / "development.md"
+        if not dev_file.exists():
+            dev_content = f"""# Development Log
+
+**Phase:** {phase or 'Phase 1'}
+**Primary Goal:** {primary_goal or 'To be defined'}
+
+## Context Sync (AUTO-UPDATED)
+
+- **Overall goal is:** {primary_goal or 'To be defined'}
+- **Last action was:** Created feature branch {branch_name}
+- **Next action will be:** {phase or 'Define first task'}
+- **Blockers:** None
+"""
+            dev_file.write_text(dev_content)
+        else:
+            # Update existing file
+            content = dev_file.read_text()
+            
+            # Update Primary Goal
+            if primary_goal:
+                import re
+                content = re.sub(
+                    r'\*\*Primary Goal:\*\*.*',
+                    f'**Primary Goal:** {primary_goal}',
+                    content
+                )
+                content = re.sub(
+                    r'Overall goal is:.*',
+                    f'Overall goal is: {primary_goal}',
+                    content
+                )
+            
+            # Update Phase
+            if phase:
+                content = re.sub(
+                    r'\*\*Phase:\*\*.*',
+                    f'**Phase:** {phase}',
+                    content
+                )
+                content = re.sub(
+                    r'Next action will be:.*',
+                    f'Next action will be: {phase}',
+                    content
+                )
+            
+            # Update Last action
+            content = re.sub(
+                r'Last action was:.*',
+                f'Last action was: Created feature branch {branch_name}',
+                content
+            )
+            
+            dev_file.write_text(content)
+        
+        # Create agents.md if missing
+        agents_file = context_dir / "agents.md"
+        if not agents_file.exists():
+            agents_content = """# Agents Guide
+
+This project uses a **Context Loop**. Always keep these fields current:
+
+- **Overall goal is:** Single-sentence mission
+- **Last action was:** What just completed
+- **Next action will be:** The very next step
+- **Blockers:** Known issues or decisions needed
+
+### Working Rules for Agents
+- Do not modify or examine ignored directories (see `.agentpackignore`). Assume large assets exist even if excluded.
+- Prefer minimal, reversible changes.
+- After committing code, run `bpsai-pair context-sync` to update the loop.
+- Request a new context pack when the tree or docs change significantly.
+
+### Context Pack
+Run `bpsai-pair pack --out agent_pack.tgz` and upload to your session.
+"""
+            agents_file.write_text(agents_content)
+        
+        # Generate project tree
+        tree_file = context_dir / "project_tree.md"
+        tree_content = f"""# Project Tree (snapshot)
+_Generated: {datetime.now(timezone.utc).isoformat()}Z_
+
+```
+{ProjectTree.generate(root)}
+```
+"""
+        tree_file.write_text(tree_content)
+        
+        # Commit changes
+        GitOps.add_commit(
+            root,
+            [dev_file, agents_file, tree_file],
+            f"feat(context): start {branch_name} — Primary Goal: {primary_goal or 'TBD'}"
+        )
+        
+        return True
+
+
+class LocalCI:
+    """Cross-platform local CI runner."""
+    
+    @staticmethod
+    def run_python_checks(root: Path) -> dict:
+        """Run Python linting, formatting, and tests."""
+        results = {}
+        
+        # Check if Python project
+        if not ((root / "pyproject.toml").exists() or (root / "requirements.txt").exists()):
+            return results
+        
+        # Try to run ruff
+        try:
+            subprocess.run(["ruff", "format", "--check", "."], cwd=root, check=True)
+            subprocess.run(["ruff", "check", "."], cwd=root, check=True)
+            results["ruff"] = "passed"
+        except:
+            results["ruff"] = "failed or not installed"
+        
+        # Try to run mypy
+        try:
+            subprocess.run(["mypy", "."], cwd=root, check=True)
+            results["mypy"] = "passed"
+        except:
+            results["mypy"] = "failed or not installed"
+        
+        # Try to run pytest
+        try:
+            subprocess.run(["pytest", "-q"], cwd=root, check=True)
+            results["pytest"] = "passed"
+        except:
+            results["pytest"] = "failed or not installed"
+        
+        return results
+    
+    @staticmethod
+    def run_node_checks(root: Path) -> dict:
+        """Run Node.js linting, formatting, and tests."""
+        results = {}
+        
+        if not (root / "package.json").exists():
+            return results
+        
+        # Try npm commands
+        try:
+            subprocess.run(["npm", "run", "lint"], cwd=root, check=True)
+            results["eslint"] = "passed"
+        except:
+            results["eslint"] = "failed or not configured"
+        
+        try:
+            subprocess.run(["npm", "test"], cwd=root, check=True)
+            results["npm test"] = "passed"
+        except:
+            results["npm test"] = "failed or not configured"
+        
+        return results
+    
+    @staticmethod
+    def run_all(root: Path) -> dict:
+        """Run all applicable CI checks."""
+        results = {
+            "python": LocalCI.run_python_checks(root),
+            "node": LocalCI.run_node_checks(root)
+        }
+        return results

bpsai_pair/pyutils.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Iterable, List
+
+def project_files(root: Path, excludes: Iterable[str] | None = None) -> List[Path]:
+    """
+    Return project files relative to root, respecting simple directory/file excludes.
+    Excludes are glob-like segments (e.g., '.git/', '.venv/', '__pycache__/').
+    This is intentionally minimal and cross-platform safe.
+    """
+    ex = list(excludes or [])
+    out: List[Path] = []
+    for p in root.rglob("*"):
+        rel = p.relative_to(root)
+        # skip directories that match excludes early
+        if any(str(rel).startswith(e.rstrip("/")) for e in ex):
+            # if it's a dir, skip its subtree
+            if p.is_dir():
+                # rely on rglob: cannot prune; filtering below suffices
+                pass
+        if p.is_file():
+            s = str(rel)
+            if any(s.startswith(e.rstrip("/")) for e in ex):
+                continue
+            out.append(rel)
+    return out

bpsai_pair/utils.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+def repo_root() -> Path:
+    p = Path.cwd()
+    if not (p / ".git").exists():
+        raise SystemExit("Run from repo root (where .git exists).")
+    return p
+
+def ensure_executable(path: Path) -> None:
+    mode = path.stat().st_mode
+    path.chmod(mode | 0o111)

bpsai_pair-0.2.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: bpsai-pair
+Version: 0.2.0
+Summary: CLI for AI pair-coding workflow
+Author: BPS AI Software
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.7
+Requires-Dist: pyyaml>=6.0
+
+
+# bpsai-pair CLI
+
+## Quick start (local, un-packaged)
+```
+python -m tools.cli.bpsai_pair --help
+python -m tools.cli.bpsai_pair init tools/cookiecutter-paircoder
+python -m tools.cli.bpsai_pair feature auth-di --primary "Decouple auth via DI" --phase "Refactor auth + tests"
+python -m tools.cli.bpsai_pair pack --extra README.md
+python -m tools.cli.bpsai_pair context-sync --last "initialized scaffolding" --nxt "set up CI secrets" --blockers "none"
+```
+
+## Install as a CLI
+```
+cd tools/cli
+pip install -e .
+# now available as: bpsai-pair --help
+```

bpsai_pair-0.2.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+bpsai_pair/__init__.py,sha256=LpEf96Jx3tRBAzZZ8ZkPU7yWnTduFq_vZYru2jLa1Rs,379
+bpsai_pair/__main__.py,sha256=Qd-f8z2Q2vpiEP2x6PBFsJrpACWDVxFKQk820MhFmHo,59
+bpsai_pair/adapters.py,sha256=oowin5juQ9dTRwpHD8eJGBCahI2BoQZVEAhueDD821Y,323
+bpsai_pair/cli.py,sha256=qc5Pcr8gUG-xuJtrqqMT-kxlHi6zUyPDIUrOIuE_110,18422
+bpsai_pair/config.py,sha256=OIBaBkjz_jNsms4zjFxnmEN9gpqRLk1FTPq4ZBNkAUM,8750
+bpsai_pair/init_bundled_cli.py,sha256=AjtdC7yt4p-FatYt5y65XEwH9CtSFKnRc09cgb0di3I,1906
+bpsai_pair/jsonio.py,sha256=C_n42gPLRqjpif-AO0vjE3G1ae_v_PT3cywu7J4Xx-M,189
+bpsai_pair/ops.py,sha256=wYVhZ5XNfRjBkr3Ztvp6j1bBW-0bOggyAQOCVHmjPuA,14706
+bpsai_pair/pyutils.py,sha256=5ub27mF4OIaGDm7CDacXsU_9FUZVaPOnYp2NyavFydo,998
+bpsai_pair/utils.py,sha256=TzaN27qKsBlRQCYHBcA06ufQERcc1fcyyOY7QlJQv8M,289
+bpsai_pair/data/cookiecutter-paircoder/cookiecutter.json,sha256=FoaPEPabd5AneVMamzBSw6QNsLZ3DhJRkNtmPOVtSIY,346
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.agentpackignore,sha256=4NkboG3S3zI736evJVm4RTjmzFxx_hvMi6KTBaGnLxU,130
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.editorconfig,sha256=Qpd1apKmHcq5gVWI8jpoxAbY_LF_04tkclK06aE2lB0,235
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.gitignore,sha256=ylldDXITCRrj038OGp1pBwihuM4SA6vDvThOvilZV0Q,47
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.gitleaks.toml,sha256=STXJmj13hqxp9ejb2hImc1h72BPB_1qsgT_b86o0HYA,373
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.pre-commit-config.yaml,sha256=o9AmanEQcUJCYOlnKg4SNcA_rviJKbczGiijyp9oSdY,1021
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/CODEOWNERS,sha256=vWB4d6NzBm1qlhLs_4uFQFz6UDICn5Ehn0NUqvXlMYo,715
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/CONTRIBUTING.md,sha256=KdZ4GjoyWMSS_kSb4zI0riALXkGuXmsiT09yH5X3Ac4,1191
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/SECURITY.md,sha256=L6teX1-0xxToQek2m5lR8iEZlJdzg2TYwpSIIKZDTzE,495
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.github/PULL_REQUEST_TEMPLATE.md,sha256=VbjBqMsIcryg3YY8TL8NsGnnzE1Thz43MrBaI3-m5mU,1146
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.github/workflows/ci.yml,sha256=VisTKdEHgnL6902gqKczr5FXFZgJlmA0zw2FJBMjb2Q,2766
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/.github/workflows/project_tree.yml,sha256=QXS7BCkua_digYmhhSJtWhVcPrEhVJWbRTqIstdK1nw,1146
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/context/agents.md,sha256=yUgVqo5BuU5l3oX1hrRCzjLtvItvfArknxQ7ElrEzo4,836
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/context/agents.md.bak,sha256=jO9h6OnstcQmcejpO4BBnjX4USZUuSBDZ0U4GJf0tv0,6813
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/context/development.md,sha256=wQIGHsI6YDQ_hv1Ps-xYXf9vLmGi73rWbwTGOzt2S60,295
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/context/development.md.bak,sha256=Nm0e5ZNsTWawkcwU61m-6MFwseWouakPMWCwxCNElUY,251
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/context/project_tree.md,sha256=ppNgU2afWoJOnSJbOl9GoJ8EuNT85N005_8LjilEN4w,89
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/context/directory_notes/.gitkeep,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/prompts/deep_research.yml,sha256=lhHG4JRi9Zdsq5J8TNaw2HeupD5oD7mm5J0XPNg1H9A,958
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/prompts/implementation.yml,sha256=co2EmK7ojw3lqeNXf99rlU3wxn6mrSuVAZGMlOEZHt4,639
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/prompts/roadmap.yml,sha256=EIdCo_EZpPZ9GXXg71IDgMooychyarWPpulojrcGIg8,498
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/scripts/README.md,sha256=gnZc_VUQPU81z7SIh3VqTqh0JPJJecKWmqWh-eBgJpU,358
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/src/.gitkeep,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/templates/adr.md,sha256=y_9hvwCgzukpV2pYOjYGk4kD-a6YZZZJqflMjnHvbLE,460
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/templates/directory_note.md,sha256=FnNMtnD_CpvVzpp5VzQzS4qddFQ6jfyS8q36ff10DrA,346
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/tests/example_contract/README.md,sha256=x5ZpsFnN9QiMWtXJsYw9n27ik5Yf425N5tbzMKOpVQQ,109
+bpsai_pair/data/cookiecutter-paircoder/{{cookiecutter.project_slug}}/tests/example_integration/README.md,sha256=_G9MzJQq1GR4fVSgGeUFVo2eyzDXJVQn6mqJ5He1Euk,150
+bpsai_pair-0.2.0.dist-info/METADATA,sha256=jBUABNC5sNe8WFZ4oR_SPNAOBfsi8ITw3ufXBielzPk,813
+bpsai_pair-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bpsai_pair-0.2.0.dist-info/entry_points.txt,sha256=tK6yOUS1oseLus0bPQYd2cuLJgL1Zr3AGb_YPHVCtCI,101
+bpsai_pair-0.2.0.dist-info/top_level.txt,sha256=kwTlUncK6pxJyQpZQdspexSc-kWtPvZkLUy4ji1P6LU,11
+bpsai_pair-0.2.0.dist-info/RECORD,,

bpsai_pair-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bpsai_pair-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bpsai-pair = bpsai_pair.cli:run
+bpsai-pair-init = bpsai_pair.init_bundled_cli:main

bpsai_pair-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bpsai_pair