piagentsync 0.0.1rc0__py3-none-any.whl

piagentsync/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1-rc"

piagentsync/cli.py

@@ -0,0 +1,272 @@
+"""CLI entry point for piagentsync."""
+
+import hashlib
+from pathlib import Path
+
+import typer
+from pydantic import ValidationError
+from rich.console import Console
+from rich.table import Table
+
+from . import __version__
+from .config import Settings, get_settings
+from .errors import ManifestNotFoundError, ManifestParseError, PiAgentSyncError
+from .manifest import parse_manifest
+from .models import ProjectManifest, SyncEntry
+from .sync import collect_entries, collect_global_entries, sync_entries
+
+app = typer.Typer()
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", help="Print version and exit"),
+) -> None:
+    if version:
+        console.print(f"piagentsync {__version__}")
+        raise typer.Exit(0)
+
+
+@app.command()
+def pull(
+    project: str | None = typer.Argument(None, help="Project name"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", "--no-dry-run", help="Preview changes without writing"
+    ),
+    global_sync: bool = typer.Option(
+        False, "--global", "--no-global", help="Also sync global agents"
+    ),
+    all_projects: bool = typer.Option(
+        False, "--all", "--no-all", help="Sync all discovered projects"
+    ),
+) -> None:
+    """Sync projects from vault to workspace."""
+    if project is None and not all_projects:
+        console.print("[red]Error:[/] Must specify a project name or use --all flag")
+        raise typer.Exit(1)
+    if project is not None and all_projects:
+        console.print("[red]Error:[/] Cannot specify both project and --all")
+        raise typer.Exit(1)
+
+    settings = get_settings()
+    if not settings.vault_path.exists():
+        console.print(f"[red]Vault not found:[/] {settings.vault_path}")
+        raise typer.Exit(1)
+
+    if all_projects:
+        projects_dir = settings.vault_path / "projects"
+        if not projects_dir.exists():
+            console.print("[yellow]No projects found (directory missing)[/]")
+            raise typer.Exit(0)
+        project_names = [p.name for p in projects_dir.iterdir() if p.is_dir()]
+        any_errors = False
+        for proj_name in project_names:
+            try:
+                _sync_single_project(proj_name, dry_run, global_sync, settings)
+            except typer.Exit:
+                any_errors = True
+        if any_errors:
+            raise typer.Exit(1)
+    else:
+        _sync_single_project(project, dry_run, global_sync, settings)
+
+
+def _sync_single_project(
+    project: str, dry_run: bool, global_sync: bool, settings: Settings
+) -> None:
+    manifest_path = settings.vault_path / "projects" / project / "AGENTS.md"
+    try:
+        manifest = parse_manifest(manifest_path)
+    except ManifestNotFoundError:
+        console.print(f"[red]Manifest not found for project:[/] {project}")
+        raise typer.Exit(1)
+    except ManifestParseError as e:
+        console.print(f"[red]Failed to parse manifest for project {project}:[/] {e}")
+        raise typer.Exit(1)
+
+    entries = collect_entries(manifest, settings)
+    if global_sync:
+        try:
+            global_entries = collect_global_entries(settings)
+            entries.extend(global_entries)
+        except Exception as e:
+            console.print(f"[yellow]Warning:[/] Failed to collect global agents: {e}")
+
+    result = sync_entries(entries, dry_run=dry_run)
+    if dry_run:
+        console.print("[yellow]Dry run enabled; no files were written.[/]")
+    _print_sync_result(result)
+    if result.has_errors:
+        raise typer.Exit(1)
+
+
+def _print_sync_result(result) -> None:
+    table = Table()
+    table.add_column("Name")
+    table.add_column("Kind")
+    table.add_column("Status")
+    for entry in result.written:
+        table.add_row(entry.name, entry.kind, "written")
+    for entry in result.skipped:
+        table.add_row(entry.name, entry.kind, "skipped")
+    for entry, error_msg in result.errors:
+        table.add_row(entry.name, entry.kind, f"error: {error_msg}")
+    console.print(table)
+    console.print(result.summary_line)
+
+
+@app.command()
+def status(
+    project: str | None = typer.Argument(None, help="Project name (optional)"),
+) -> None:
+    """Show sync status without writing."""
+    settings = get_settings()
+    if not settings.vault_path.exists():
+        console.print(f"[red]Vault not found:[/] {settings.vault_path}")
+        raise typer.Exit(1)
+
+    if project is None:
+        projects_dir = settings.vault_path / "projects"
+        if not projects_dir.exists():
+            console.print("[yellow]No projects found[/]")
+            return
+        project_names = [p.name for p in projects_dir.iterdir() if p.is_dir()]
+        all_entries: list[tuple[str, SyncEntry]] = []
+        for proj_name in project_names:
+            try:
+                manifest = parse_manifest(projects_dir / proj_name / "AGENTS.md")
+                entries = collect_entries(manifest, settings)
+                all_entries.extend([(proj_name, e) for e in entries])
+            except PiAgentSyncError as e:
+                console.print(f"[red]Error loading project {proj_name}:[/] {e}")
+        _display_status(all_entries)
+    else:
+        manifest_path = settings.vault_path / "projects" / project / "AGENTS.md"
+        try:
+            manifest = parse_manifest(manifest_path)
+        except ManifestNotFoundError:
+            console.print(f"[red]Manifest not found for project:[/] {project}")
+            raise typer.Exit(1)
+        except ManifestParseError as e:
+            console.print(f"[red]Failed to parse manifest:[/] {e}")
+            raise typer.Exit(1)
+        entries = collect_entries(manifest, settings)
+        _display_status([(project, e) for e in entries])
+
+
+def _display_status(entries_with_project: list[tuple[str, SyncEntry]]) -> None:
+    table = Table()
+    table.add_column("Project")
+    table.add_column("Name")
+    table.add_column("Kind")
+    table.add_column("Local")
+    table.add_column("Vault")
+    table.add_column("State")
+    for proj, entry in entries_with_project:
+        # Determine state and local presence
+        dest = entry.destination
+        if dest.exists():
+            try:
+                with open(entry.source, "rb") as f:
+                    src_hash = hashlib.sha256(f.read()).hexdigest()
+                with open(dest, "rb") as f:
+                    dst_hash = hashlib.sha256(f.read()).hexdigest()
+                if src_hash == dst_hash:
+                    state = "in sync"
+                else:
+                    state = "differs"
+                local_desc = "present"
+            except OSError as e:
+                state = f"error: {e}"
+                local_desc = "present?"
+        else:
+            state = "needs pull"
+            local_desc = "missing"
+        vault_desc = "present"
+        table.add_row(proj, entry.name, entry.kind, local_desc, vault_desc, state)
+    console.print(table)
+
+
+@app.command()
+def init(
+    project: str = typer.Argument(..., help="Project slug"),
+    workspace: Path = typer.Option(
+        ..., "--workspace", "-w", help="Workspace directory"
+    ),
+    notion_board_id: str | None = typer.Option(
+        None, "--notion-board-id", help="Notion board ID"
+    ),
+    notion_project_filter: str | None = typer.Option(
+        None,
+        "--notion-project-filter",
+        help="Notion project filter (defaults to project slug)",
+    ),
+) -> None:
+    """Scaffold a new project in the vault."""
+    # Validate project slug early using ProjectManifest
+    try:
+        manifest = ProjectManifest(
+            project=project,
+            workspace=workspace,
+            notion_board_id=notion_board_id,
+            notion_project_filter=notion_project_filter or project,
+        )
+    except ValidationError as e:
+        console.print(f"[red]Invalid project slug:[/] {e}")
+        raise typer.Exit(1)
+
+    settings = get_settings()
+    project_dir = settings.vault_path / "projects" / project
+    if project_dir.exists():
+        console.print(f"[red]Project directory already exists:[/] {project_dir}")
+        raise typer.Exit(1)
+
+    try:
+        project_dir.mkdir(parents=True, exist_ok=False)
+        (project_dir / "agents").mkdir()
+        (project_dir / "skills").mkdir()
+        (project_dir / "context.md").write_text("")
+        (project_dir / "decisions.md").write_text("")
+    except OSError as e:
+        console.print(f"[red]Failed to create project directories:[/] {e}")
+        raise typer.Exit(1)
+
+    # Build AGENTS.md content
+    frontmatter = [
+        "---",
+        f"project: {manifest.project}",
+        f"workspace: {workspace}",
+    ]
+    if manifest.notion_board_id:
+        frontmatter.append(f"notion_board_id: {manifest.notion_board_id}")
+    if manifest.notion_project_filter:
+        frontmatter.append(f"notion_project_filter: {manifest.notion_project_filter}")
+    frontmatter.append("---")
+    frontmatter_body = "\n".join(frontmatter)
+
+    body = f"""# {project} — agent routing
+
+## Stack
+
+_Fill in the tech stack._
+
+## Agent routing
+
+| Task | Agent |
+|------|-------|
+| _example_ | _example-agent_ |
+"""
+    agents_md_content = frontmatter_body + "\n\n" + body
+    try:
+        (project_dir / "AGENTS.md").write_text(agents_md_content)
+        # Add .gitkeep files
+        (project_dir / "agents" / ".gitkeep").write_text("")
+        (project_dir / "skills" / ".gitkeep").write_text("")
+    except OSError as e:
+        console.print(f"[red]Failed to write manifest files:[/] {e}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]Project initialized:[/] {project}")
+    console.print(f"Next step: piagentsync pull {project}")

piagentsync/config.py

@@ -0,0 +1,38 @@
+"""Configuration management for piagentsync."""
+
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    vault_path: Path = Field(
+        default=Path("~/vault"), description="Path to Obsidian vault"
+    )
+    global_opencode_path: Path = Field(
+        default=Path("~/.config/opencode"),
+        description="Path to global OpenCode config",
+    )
+
+    model_config = {
+        "env_prefix": "PIAGENTSYNC_",
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+    }
+
+    @field_validator("vault_path", "global_opencode_path", mode="after")
+    @classmethod
+    def expand_paths(cls, v: Path) -> Path:
+        """Expand user home and resolve to absolute path."""
+        return v.expanduser().resolve()
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    """Return a cached Settings instance."""
+    return Settings()

piagentsync/errors.py

@@ -0,0 +1,33 @@
+"""Custom exception hierarchy for piagentsync."""
+
+
+class PiAgentSyncError(Exception):
+    """Base exception for all piagentsync errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+
+class ManifestNotFoundError(PiAgentSyncError):
+    """Raised when an AGENTS.md manifest file does not exist."""
+
+    pass
+
+
+class ManifestParseError(PiAgentSyncError):
+    """Raised when manifest parsing fails (missing or malformed frontmatter)."""
+
+    pass
+
+
+class VaultNotFoundError(PiAgentSyncError):
+    """Raised when the vault directory does not exist."""
+
+    pass
+
+
+class SyncError(PiAgentSyncError):
+    """Raised for general sync failures (e.g., file system errors)."""
+
+    pass

piagentsync/manifest.py

@@ -0,0 +1,30 @@
+"""Manifest parser using python-frontmatter."""
+
+from pathlib import Path
+
+import frontmatter
+
+from .errors import ManifestNotFoundError, ManifestParseError
+from .models import ProjectManifest
+
+
+def parse_manifest(path: Path) -> ProjectManifest:
+    """Parse YAML frontmatter from an AGENTS.md file.
+
+    Raises:
+        ManifestNotFoundError: If the file does not exist.
+        ManifestParseError: If frontmatter is missing or malformed.
+        pydantic.ValidationError: If required fields fail validation.
+    """
+    if not path.exists():
+        raise ManifestNotFoundError(f"Manifest file not found: {path}")
+
+    try:
+        post = frontmatter.load(str(path))
+    except Exception as e:
+        raise ManifestParseError(f"Failed to parse frontmatter: {e}") from e
+
+    if not post.metadata:
+        raise ManifestParseError("No frontmatter found")
+
+    return ProjectManifest(**post.metadata)

piagentsync/models.py

@@ -0,0 +1,82 @@
+"""Data models for piagentsync."""
+
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class EntryKind:
+    """Enum-like class for sync entry kinds."""
+
+    AGENT = "agent"
+    SKILL = "skill"
+    CONTEXT_FILE = "context_file"
+
+
+class ProjectManifest(BaseModel):
+    """Manifest parsed from AGENTS.md frontmatter."""
+
+    model_config = ConfigDict(frozen=True)
+
+    project: str = Field(..., min_length=1, description="Project slug")
+    workspace: Path = Field(..., description="Workspace directory path")
+    notion_board_id: str | None = Field(None, description="Optional Notion DB ID")
+    notion_project_filter: str | None = Field(
+        None, description="Optional Notion project filter"
+    )
+
+    @field_validator("project")
+    @classmethod
+    def validate_project_slug(cls, v: str) -> str:
+        """Project slug must be lowercase alphanumeric with hyphens."""
+        import re
+
+        if not re.match(r"^[a-z0-9-]+$", v):
+            raise ValueError("project must be lowercase letters, numbers, and hyphens")
+        return v
+
+    @field_validator("workspace", mode="after")
+    @classmethod
+    def expand_workspace(cls, v: Path) -> Path:
+        """Expand and resolve workspace path."""
+        return v.expanduser().resolve()
+
+
+class SyncEntry(BaseModel):
+    """Represents a single file to sync."""
+
+    model_config = ConfigDict(frozen=True)
+
+    name: str = Field(..., description="Filename stem (without extension)")
+    source: Path = Field(..., description="Absolute source path in vault")
+    destination: Path = Field(..., description="Absolute destination path in workspace")
+    kind: str = Field(..., description="Entry kind: agent, skill, or context_file")
+
+
+class SyncResult(BaseModel):
+    """Result of a sync operation."""
+
+    model_config = ConfigDict(frozen=True)
+
+    written: list[SyncEntry] = Field(default_factory=list, description="Files written")
+    skipped: list[SyncEntry] = Field(
+        default_factory=list, description="Files skipped (unchanged)"
+    )
+    errors: list[tuple[SyncEntry, str]] = Field(
+        default_factory=list, description="(entry, error message) pairs"
+    )
+
+    @property
+    def total(self) -> int:
+        """Total entries processed (written + skipped + errors)."""
+        return len(self.written) + len(self.skipped) + len(self.errors)
+
+    @property
+    def has_errors(self) -> bool:
+        """True if any errors occurred during sync."""
+        return len(self.errors) > 0
+
+    @property
+    def summary_line(self) -> str:
+        """One-line summary: 'N written · N skipped · N errors'."""
+        return f"{len(self.written)} written · {len(self.skipped)} skipped · {len(self.errors)} errors"

piagentsync/sync.py

@@ -0,0 +1,116 @@
+"""Core synchronization logic."""
+
+import hashlib
+
+from .config import Settings
+from .models import EntryKind, ProjectManifest, SyncEntry, SyncResult
+
+
+def collect_entries(manifest: ProjectManifest, settings: Settings) -> list[SyncEntry]:
+    """Collect all syncable entries for a project."""
+    vault = settings.vault_path
+    project_dir = vault / "projects" / manifest.project
+    entries: list[SyncEntry] = []
+
+    # Agents
+    agents_dir = project_dir / "agents"
+    if agents_dir.is_dir():
+        for file in agents_dir.iterdir():
+            if file.is_file() and file.suffix.lower() == ".md":
+                dest = manifest.workspace / ".opencode" / "agents" / file.name
+                entries.append(
+                    SyncEntry(
+                        name=file.stem,
+                        source=file.resolve(),
+                        destination=dest,
+                        kind=EntryKind.AGENT,
+                    )
+                )
+
+    # Skills
+    skills_dir = project_dir / "skills"
+    if skills_dir.is_dir():
+        for file in skills_dir.iterdir():
+            if file.is_file() and file.suffix.lower() == ".md":
+                dest = manifest.workspace / ".opencode" / "skills" / file.name
+                entries.append(
+                    SyncEntry(
+                        name=file.stem,
+                        source=file.resolve(),
+                        destination=dest,
+                        kind=EntryKind.SKILL,
+                    )
+                )
+
+    # AGENTS.md (context file)
+    agents_md = project_dir / "AGENTS.md"
+    if agents_md.is_file():
+        dest = manifest.workspace / ".opencode" / "AGENTS.md"
+        entries.append(
+            SyncEntry(
+                name=agents_md.stem,
+                source=agents_md.resolve(),
+                destination=dest,
+                kind=EntryKind.CONTEXT_FILE,
+            )
+        )
+
+    return entries
+
+
+def collect_global_entries(settings: Settings) -> list[SyncEntry]:
+    """Collect all global agent entries."""
+    vault = settings.vault_path
+    global_dir = vault / "agents" / "global"
+    entries: list[SyncEntry] = []
+    if global_dir.is_dir():
+        dest_dir = settings.global_opencode_path / "agents"
+        for file in global_dir.iterdir():
+            if file.is_file() and file.suffix.lower() == ".md":
+                dest = dest_dir / file.name
+                entries.append(
+                    SyncEntry(
+                        name=file.stem,
+                        source=file.resolve(),
+                        destination=dest,
+                        kind=EntryKind.AGENT,
+                    )
+                )
+    return entries
+
+
+def sync_entries(entries: list[SyncEntry], dry_run: bool = False) -> SyncResult:
+    """Synchronize entries from source to destination."""
+    written: list[SyncEntry] = []
+    skipped: list[SyncEntry] = []
+    errors: list[tuple[SyncEntry, str]] = []
+
+    for entry in entries:
+        try:
+            if not entry.source.exists():
+                raise FileNotFoundError(f"Source file not found: {entry.source}")
+
+            with open(entry.source, "rb") as f:
+                src_content = f.read()
+            src_hash = hashlib.sha256(src_content).hexdigest()
+
+            dest = entry.destination
+            if dest.exists():
+                with open(dest, "rb") as f:
+                    dest_content = f.read()
+                dest_hash = hashlib.sha256(dest_content).hexdigest()
+                if src_hash == dest_hash:
+                    skipped.append(entry)
+                    continue
+
+            if not dry_run:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                with open(dest, "wb") as f:
+                    f.write(src_content)
+
+            written.append(entry)
+
+        except OSError as e:
+            errors.append((entry, str(e)))
+
+    return SyncResult(written=written, skipped=skipped, errors=errors)

piagentsync-0.0.1rc0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: piagentsync
+Version: 0.0.1rc0
+Summary: Sync OpenCode agents and skills from an Obsidian vault to workspace directories
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: pydantic-settings>=2.3
+Requires-Dist: pydantic>=2.7
+Requires-Dist: python-frontmatter>=1.1
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# piagentsync
+
+Sync OpenCode agents and skills from an Obsidian vault to workspace directories.
+
+## Install
+
+```bash
+uv add piagentsync
+# or
+pip install piagentsync
+```
+
+## Quick start
+
+1. Initialize a new project in your vault:
+
+```bash
+piagentsync init myproject --workspace ~/workspace/myproject
+```
+
+2. Pull the synced files to your workspace:
+
+```bash
+piagentsync pull myproject
+```
+
+## Configuration
+
+Environment variables (also configurable via `.env` file):
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PIAGENTSYNC_VAULT_PATH` | `~/vault` | Path to Obsidian vault |
+| `PIAGENTSYNC_GLOBAL_OPENCODE_PATH` | `~/.config/opencode` | Path to global OpenCode config |
+
+## CLI reference
+
+### `piagentsync pull <project>`
+
+Sync a single project from vault to workspace.
+
+Options:
+- `--dry-run` / `--no-dry-run` — preview changes without writing
+- `--global` / `--no-global` — also sync global agents
+- `--all` — sync all discovered projects
+
+### `piagentsync status [project]`
+
+Show diff between vault and workspace.
+
+Options:
+- `--all` — show status for all projects (default when no project given)
+
+### `piagentsync init <project>`
+
+Scaffold a new project in the vault.
+
+Options:
+- `--workspace PATH` — required, workspace directory
+- `--notion-board-id TEXT` — optional Notion DB ID
+- `--notion-project-filter TEXT` — optional Notion project filter (defaults to project slug)
+
+### `--version`
+
+Print version and exit.
+
+## AGENTS.md manifest format
+
+Each project must have an `AGENTS.md` file in its root with YAML frontmatter:
+
+```yaml
+---
+project: myproject
+workspace: ~/workspace/myproject
+notion_board_id: 3305f9479a8d8055b3c3e86a9006cf91
+notion_project_filter: myproject
+---
+```
+
+The body below the frontmatter is the OpenCode routing table.
+
+## Expected vault structure
+
+```
+vault/
+├── agents/
+│   └── global/
+│       └── *.md
+└── projects/
+    └── {project}/
+        ├── AGENTS.md           # manifest with frontmatter
+        ├── context.md          # optional context file
+        ├── decisions.md        # optional decisions log
+        ├── agents/
+        │   └── *.md
+        └── skills/
+            └── *.md
+```
+
+## Contributing
+
+Development setup:
+
+```bash
+uv sync
+uv run pytest
+```
+
+Lint and format:
+
+```bash
+uv run ruff check src/ tests/
+uv run ruff format src/ tests/
+```
+
+All commits follow [Conventional Commits](https://www.conventionalcommits.org/).
+
+### Publishing (maintainers)
+
+This repository uses GitHub Actions for CI and automated releases.
+
+#### One-time PyPI setup (trusted publisher)
+
+1. Enable OIDC on PyPI for the repository:
+   - Publisher: GitHub Actions
+   - Repository owner: `Piwero`
+   - Repository name: `piagentsync`
+   - Workflow filename: `publish.yml`
+   - Environment name: (leave blank)
+
+2. Push a tag to trigger the `tag.yml` workflow to bump version and create a git tag.
+
+3. After the tag workflow completes, the `publish.yml` workflow will automatically build and publish the package to PyPI.
+
+#### Release process
+
+```text
+git push → ci.yml passes
+   → trigger tag.yml (choose MAJOR/MINOR/PATCH/RC)
+       → tests re-run → version bumped → tag pushed
+   → trigger publish.yml
+       → tests re-run → built → published to PyPI
+```
+
+## License
+
+MIT

piagentsync-0.0.1rc0.dist-info/RECORD

@@ -0,0 +1,12 @@
+piagentsync/__init__.py,sha256=eAmeXLaXDnlioXR5SPcKxvWxKEyvC8SHO7PgPLtfNQ8,25
+piagentsync/cli.py,sha256=QJhv0_dwGy5_kx2uNmaSIRsuIxZm9EvQ6Jpi2vjswdM,9618
+piagentsync/config.py,sha256=yaVX-brXMcGx0UhwXyzx2xsIMvLg79nfzwPJ2m5Bf0Y,1067
+piagentsync/errors.py,sha256=kaPaBzlCAyDh86U9Hn7KhvpeDUmlTdjCM9G6Q394_FA,745
+piagentsync/manifest.py,sha256=5nXqZzhNoj4n0SqrTYiDocaTNQi9uandqCDhjlLR5-g,902
+piagentsync/models.py,sha256=kH8BdszN7JCJ-EQPhMQSTnnsSWPvofJiuG8CbdjyXR0,2727
+piagentsync/sync.py,sha256=DAOfkmgBAOJ_JYXjjMKqFnCd7jSmvTy19y9qFLIbszQ,3943
+piagentsync-0.0.1rc0.dist-info/METADATA,sha256=ZcS2PtoCivBIT2OleWDw5LpgLcqo_G2YDBooLjUQBF4,3746
+piagentsync-0.0.1rc0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+piagentsync-0.0.1rc0.dist-info/entry_points.txt,sha256=bYGWj8MEC3oKRodPutyXVKH59ZhHa35AHol3dGC5neM,52
+piagentsync-0.0.1rc0.dist-info/licenses/LICENSE,sha256=DcZJcxG6YDw4d0E0UTfJIjfzCy1g8txOmxr5fVY9en0,1063
+piagentsync-0.0.1rc0.dist-info/RECORD,,

piagentsync-0.0.1rc0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

piagentsync-0.0.1rc0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+piagentsync = piagentsync.cli:app

piagentsync-0.0.1rc0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piwero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.