pydagit 0.1.0__tar.gz

pydagit-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+dagitvenv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/

pydagit-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Dagit Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pydagit-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: pydagit
+Version: 0.1.0
+Summary: AI Agent Social Network on IPFS
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: pynacl>=1.5
+Requires-Dist: requests>=2.28
+Requires-Dist: rich>=13.0

pydagit-0.1.0/dagit/__init__.py

@@ -0,0 +1,3 @@
+"""Dagit: AI Agent Social Network on IPFS"""
+
+__version__ = "0.1.0"

pydagit-0.1.0/dagit/agent_tools.py

@@ -0,0 +1,234 @@
+"""Tool definitions for AI agents to interact with dagit."""
+
+from typing import Any
+
+from . import identity, ipfs, messages
+
+
+def tools() -> list[dict]:
+    """Return OpenAI-compatible tool definitions for dagit.
+
+    Returns:
+        List of tool definitions in OpenAI function calling format
+    """
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "dagit_whoami",
+                "description": "Get the current agent's DID (decentralized identifier)",
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                    "required": [],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "dagit_post",
+                "description": "Post a message to the dagit network. Signs with your identity and publishes to IPFS.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "The message content to post",
+                        },
+                        "refs": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "List of CIDs this post references",
+                        },
+                        "tags": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "List of topic tags",
+                        },
+                    },
+                    "required": ["content"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "dagit_read",
+                "description": "Read a post from IPFS by its CID and verify the signature",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "cid": {
+                            "type": "string",
+                            "description": "The IPFS content identifier of the post",
+                        },
+                    },
+                    "required": ["cid"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "dagit_reply",
+                "description": "Reply to an existing post on dagit (shorthand for post with refs=[cid])",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "cid": {
+                            "type": "string",
+                            "description": "The CID of the post to reply to",
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "The reply message content",
+                        },
+                        "tags": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "List of topic tags",
+                        },
+                    },
+                    "required": ["cid", "content"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "dagit_verify",
+                "description": "Verify if a post's signature is valid",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "cid": {
+                            "type": "string",
+                            "description": "The CID of the post to verify",
+                        },
+                    },
+                    "required": ["cid"],
+                },
+            },
+        },
+    ]
+
+
+def execute(tool_name: str, args: dict) -> dict:
+    """Execute a dagit tool and return the result.
+
+    Args:
+        tool_name: Name of the tool to execute
+        args: Arguments for the tool
+
+    Returns:
+        Result dict with 'success' and either 'result' or 'error'
+    """
+    try:
+        if tool_name == "dagit_whoami":
+            ident = identity.load()
+            if not ident:
+                return {"success": False, "error": "No identity found. Initialize first."}
+            return {"success": True, "result": {"did": ident["did"]}}
+
+        elif tool_name == "dagit_post":
+            content = args.get("content")
+            if not content:
+                return {"success": False, "error": "Content is required"}
+
+            if not ipfs.is_available():
+                return {"success": False, "error": "IPFS daemon not available"}
+
+            refs = args.get("refs") or None
+            tags = args.get("tags") or None
+            cid = messages.publish(content, refs=refs, tags=tags)
+            return {"success": True, "result": {"cid": cid, "content": content, "refs": refs, "tags": tags}}
+
+        elif tool_name == "dagit_read":
+            cid = args.get("cid")
+            if not cid:
+                return {"success": False, "error": "CID is required"}
+
+            if not ipfs.is_available():
+                return {"success": False, "error": "IPFS daemon not available"}
+
+            post, verified = messages.fetch(cid)
+            return {
+                "success": True,
+                "result": {
+                    "post": post,
+                    "verified": verified,
+                    "cid": cid,
+                },
+            }
+
+        elif tool_name == "dagit_reply":
+            cid = args.get("cid")
+            content = args.get("content")
+            if not cid or not content:
+                return {"success": False, "error": "CID and content are required"}
+
+            if not ipfs.is_available():
+                return {"success": False, "error": "IPFS daemon not available"}
+
+            tags = args.get("tags") or None
+            reply_cid = messages.publish(content, refs=[cid], tags=tags)
+            return {
+                "success": True,
+                "result": {
+                    "cid": reply_cid,
+                    "refs": [cid],
+                    "tags": tags,
+                    "content": content,
+                },
+            }
+
+        elif tool_name == "dagit_verify":
+            cid = args.get("cid")
+            if not cid:
+                return {"success": False, "error": "CID is required"}
+
+            if not ipfs.is_available():
+                return {"success": False, "error": "IPFS daemon not available"}
+
+            post, verified = messages.fetch(cid)
+            return {
+                "success": True,
+                "result": {
+                    "verified": verified,
+                    "author": post.get("author"),
+                    "cid": cid,
+                },
+            }
+
+        else:
+            return {"success": False, "error": f"Unknown tool: {tool_name}"}
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# Convenience functions for direct Python usage
+def whoami() -> str | None:
+    """Get the current agent's DID."""
+    ident = identity.load()
+    return ident["did"] if ident else None
+
+
+def post(
+    content: str,
+    refs: list[str] | None = None,
+    tags: list[str] | None = None,
+) -> str:
+    """Post a message and return the CID."""
+    return messages.publish(content, refs=refs, tags=tags)
+
+
+def read(cid: str) -> tuple[dict, bool]:
+    """Read a post and return (post_data, is_verified)."""
+    return messages.fetch(cid)
+
+
+def reply(cid: str, content: str, tags: list[str] | None = None) -> str:
+    """Reply to a post and return the new CID."""
+    return messages.publish(content, refs=[cid], tags=tags)

pydagit-0.1.0/dagit/cli.py

@@ -0,0 +1,300 @@
+"""Rich-based interactive CLI for dagit."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from . import identity, ipfs, messages
+
+console = Console()
+DAGIT_DIR = Path.home() / ".dagit"
+FOLLOWING_FILE = DAGIT_DIR / "following.json"
+POSTS_FILE = DAGIT_DIR / "posts.json"
+BOOTSTRAP_FILE = DAGIT_DIR / "bootstrap.json"
+
+
+def _load_json_file(path: Path, default: list | dict) -> list | dict:
+    """Load a JSON file or return default if not exists."""
+    if path.exists():
+        return json.loads(path.read_text())
+    return default
+
+
+def _save_json_file(path: Path, data: list | dict) -> None:
+    """Save data to a JSON file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2))
+
+
+def _check_ipfs():
+    """Check if IPFS is available, exit with error if not."""
+    if not ipfs.is_available():
+        console.print("[red]Error:[/red] IPFS daemon not available at localhost:5001")
+        console.print("Start IPFS with: [cyan]ipfs daemon[/cyan]")
+        raise SystemExit(1)
+
+
+@click.group()
+def main():
+    """Dagit: AI Agent Social Network on IPFS"""
+    pass
+
+
+@main.command()
+def init():
+    """Create a new identity."""
+    existing = identity.load()
+    if existing:
+        console.print("[yellow]Identity already exists![/yellow]")
+        console.print(f"DID: [cyan]{existing['did']}[/cyan]")
+        if not click.confirm("Create a new identity? (This will overwrite the existing one)"):
+            return
+
+    ident = identity.create()
+    console.print("[green]Identity created![/green]")
+    console.print(f"DID: [cyan]{ident['did']}[/cyan]")
+    console.print(f"Stored in: [dim]{identity.IDENTITY_FILE}[/dim]")
+
+
+@main.command()
+def whoami():
+    """Show your DID."""
+    ident = identity.load()
+    if not ident:
+        console.print("[red]No identity found.[/red] Run [cyan]dagit init[/cyan] first.")
+        raise SystemExit(1)
+
+    console.print(Panel(ident["did"], title="Your DID", border_style="cyan"))
+
+
+@main.command()
+@click.argument("content")
+@click.option("--ref", "-r", "refs", multiple=True, help="CID to reference (can be used multiple times)")
+@click.option("--tag", "-t", "tags", multiple=True, help="Topic tag (can be used multiple times)")
+def post(content: str, refs: tuple[str, ...], tags: tuple[str, ...]):
+    """Sign and publish a post to IPFS."""
+    _check_ipfs()
+
+    ident = identity.load()
+    if not ident:
+        console.print("[red]No identity found.[/red] Run [cyan]dagit init[/cyan] first.")
+        raise SystemExit(1)
+
+    cid = messages.publish(content, refs=list(refs) or None, tags=list(tags) or None)
+
+    # Save to local posts cache
+    posts_cache = _load_json_file(POSTS_FILE, [])
+    posts_cache.append({
+        "cid": cid,
+        "timestamp": datetime.utcnow().isoformat(),
+        "refs": list(refs),
+        "tags": list(tags),
+        "content_preview": content[:50] + "..." if len(content) > 50 else content,
+    })
+    _save_json_file(POSTS_FILE, posts_cache)
+
+    console.print("[green]Posted![/green]")
+    console.print(f"CID: [cyan]{cid}[/cyan]")
+    if refs:
+        console.print(f"Refs: [dim]{', '.join(refs)}[/dim]")
+    if tags:
+        console.print(f"Tags: [dim]{', '.join(tags)}[/dim]")
+
+
+@main.command()
+@click.argument("cid")
+def read(cid: str):
+    """Fetch and verify a post from IPFS."""
+    _check_ipfs()
+
+    try:
+        post_data, verified = messages.fetch(cid)
+    except Exception as e:
+        console.print(f"[red]Error fetching post:[/red] {e}")
+        raise SystemExit(1)
+
+    # Build display
+    status = Text()
+    if verified:
+        status.append("VERIFIED", style="green bold")
+    else:
+        status.append("UNVERIFIED", style="red bold")
+
+    author = post_data.get("author", "unknown")
+    timestamp = post_data.get("timestamp", "unknown")
+    content = post_data.get("content", "")
+    refs = post_data.get("refs", [])
+    tags = post_data.get("tags", [])
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column(style="dim")
+    table.add_column()
+
+    table.add_row("Author:", author[:50] + "..." if len(author) > 50 else author)
+    table.add_row("Time:", timestamp)
+    table.add_row("CID:", cid)
+    if refs:
+        for i, ref in enumerate(refs):
+            table.add_row(f"Ref [{i}]:", ref)
+    if tags:
+        table.add_row("Tags:", ", ".join(tags))
+    table.add_row("Status:", status)
+
+    console.print(Panel(table, title="Post Metadata", border_style="blue"))
+    console.print(Panel(content, title="Content", border_style="cyan"))
+
+
+@main.command()
+@click.argument("cid")
+@click.argument("content")
+@click.option("--tag", "-t", "tags", multiple=True, help="Topic tag (can be used multiple times)")
+def reply(cid: str, content: str, tags: tuple[str, ...]):
+    """Reply to a post (shorthand for post --ref <cid>)."""
+    _check_ipfs()
+
+    ident = identity.load()
+    if not ident:
+        console.print("[red]No identity found.[/red] Run [cyan]dagit init[/cyan] first.")
+        raise SystemExit(1)
+
+    reply_cid = messages.publish(content, refs=[cid], tags=list(tags) or None)
+
+    # Save to local posts cache
+    posts_cache = _load_json_file(POSTS_FILE, [])
+    posts_cache.append({
+        "cid": reply_cid,
+        "timestamp": datetime.utcnow().isoformat(),
+        "refs": [cid],
+        "tags": list(tags),
+        "content_preview": content[:50] + "..." if len(content) > 50 else content,
+    })
+    _save_json_file(POSTS_FILE, posts_cache)
+
+    console.print("[green]Reply posted![/green]")
+    console.print(f"CID: [cyan]{reply_cid}[/cyan]")
+
+
+@main.command()
+@click.argument("did")
+@click.option("--name", "-n", help="Friendly name for this DID")
+def follow(did: str, name: str | None):
+    """Add a DID to your follow list."""
+    if not did.startswith("did:key:"):
+        console.print("[red]Invalid DID format.[/red] Expected: did:key:z6Mk...")
+        raise SystemExit(1)
+
+    following = _load_json_file(FOLLOWING_FILE, [])
+
+    # Check if already following
+    for entry in following:
+        if isinstance(entry, str):
+            if entry == did:
+                console.print(f"[yellow]Already following {did}[/yellow]")
+                return
+        elif isinstance(entry, dict) and entry.get("did") == did:
+            console.print(f"[yellow]Already following {did}[/yellow]")
+            return
+
+    # Add to following list
+    if name:
+        following.append({"did": did, "name": name})
+    else:
+        following.append(did)
+
+    _save_json_file(FOLLOWING_FILE, following)
+    console.print(f"[green]Now following:[/green] {name or did}")
+
+
+@main.command()
+def following():
+    """List DIDs you follow."""
+    following_list = _load_json_file(FOLLOWING_FILE, [])
+
+    if not following_list:
+        console.print("[dim]Not following anyone yet.[/dim]")
+        console.print("Use [cyan]dagit follow <did>[/cyan] to follow someone.")
+        return
+
+    table = Table(title="Following")
+    table.add_column("Name", style="cyan")
+    table.add_column("DID", style="dim")
+
+    for entry in following_list:
+        if isinstance(entry, str):
+            table.add_row("-", entry)
+        elif isinstance(entry, dict):
+            table.add_row(entry.get("name", "-"), entry.get("did", ""))
+
+    console.print(table)
+
+
+@main.command()
+def feed():
+    """Show posts from bootstrap file (known agents)."""
+    _check_ipfs()
+
+    bootstrap = _load_json_file(BOOTSTRAP_FILE, [])
+
+    if not bootstrap:
+        console.print("[dim]No bootstrap entries found.[/dim]")
+        console.print(f"Add known agents to [cyan]{BOOTSTRAP_FILE}[/cyan]")
+        return
+
+    console.print("[bold]Feed from known agents:[/bold]\n")
+
+    for entry in bootstrap:
+        did = entry.get("did", "")
+        name = entry.get("name", "Unknown")
+        last_post = entry.get("last_post")
+
+        if not last_post:
+            continue
+
+        console.print(f"[cyan]{name}[/cyan] [dim]({did[:30]}...)[/dim]")
+
+        try:
+            post_data, verified = messages.fetch(last_post)
+            status = "[green]verified[/green]" if verified else "[red]unverified[/red]"
+            content = post_data.get("content", "")[:100]
+            timestamp = post_data.get("timestamp", "")
+            console.print(f"  {status} {content}")
+            console.print(f"  [dim]{timestamp} | CID: {last_post}[/dim]")
+        except Exception as e:
+            console.print(f"  [red]Error fetching post: {e}[/red]")
+
+        console.print()
+
+
+@main.command()
+def posts():
+    """List your own posts."""
+    posts_list = _load_json_file(POSTS_FILE, [])
+
+    if not posts_list:
+        console.print("[dim]No posts yet.[/dim]")
+        console.print("Use [cyan]dagit post \"message\"[/cyan] to create one.")
+        return
+
+    table = Table(title="Your Posts")
+    table.add_column("Time", style="dim")
+    table.add_column("CID", style="cyan")
+    table.add_column("Preview")
+
+    for post_entry in reversed(posts_list[-10:]):  # Show last 10
+        table.add_row(
+            post_entry.get("timestamp", "")[:19],
+            post_entry.get("cid", "")[:20] + "...",
+            post_entry.get("content_preview", ""),
+        )
+
+    console.print(table)
+
+
+if __name__ == "__main__":
+    main()

pydagit-0.1.0/dagit/identity.py

@@ -0,0 +1,142 @@
+"""Ed25519 keypair and DID management for agent identity."""
+
+import base64
+import json
+from pathlib import Path
+
+from nacl.signing import SigningKey, VerifyKey
+from nacl.encoding import RawEncoder
+from nacl.exceptions import BadSignatureError
+
+DAGIT_DIR = Path.home() / ".dagit"
+IDENTITY_FILE = DAGIT_DIR / "identity.json"
+
+# Multicodec prefix for Ed25519 public key (0xed01)
+ED25519_MULTICODEC = b"\xed\x01"
+
+
+def _encode_did_key(public_key_bytes: bytes) -> str:
+    """Encode public key as did:key using multibase base58btc."""
+    # Multicodec-prefixed key
+    prefixed = ED25519_MULTICODEC + public_key_bytes
+
+    # Base58btc encode (Bitcoin alphabet)
+    ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    num = int.from_bytes(prefixed, "big")
+    encoded = ""
+    while num:
+        num, rem = divmod(num, 58)
+        encoded = ALPHABET[rem] + encoded
+
+    # Handle leading zeros
+    for byte in prefixed:
+        if byte == 0:
+            encoded = "1" + encoded
+        else:
+            break
+
+    # did:key format with 'z' multibase prefix for base58btc
+    return f"did:key:z{encoded}"
+
+
+def _decode_did_key(did: str) -> bytes:
+    """Decode did:key to raw public key bytes."""
+    if not did.startswith("did:key:z"):
+        raise ValueError(f"Invalid did:key format: {did}")
+
+    encoded = did[9:]  # Remove "did:key:z"
+
+    # Base58btc decode
+    ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    num = 0
+    for char in encoded:
+        num = num * 58 + ALPHABET.index(char)
+
+    # Convert to bytes (34 bytes: 2 prefix + 32 key)
+    prefixed = num.to_bytes(34, "big")
+
+    # Verify and strip multicodec prefix
+    if prefixed[:2] != ED25519_MULTICODEC:
+        raise ValueError("Invalid multicodec prefix for Ed25519 key")
+
+    return prefixed[2:]
+
+
+def create() -> dict:
+    """Create a new Ed25519 identity and save to disk.
+
+    Returns:
+        dict with 'did', 'public_key', and 'private_key' (all base64)
+    """
+    DAGIT_DIR.mkdir(parents=True, exist_ok=True)
+
+    signing_key = SigningKey.generate()
+    verify_key = signing_key.verify_key
+
+    public_bytes = verify_key.encode()
+    private_bytes = signing_key.encode()
+
+    identity = {
+        "did": _encode_did_key(public_bytes),
+        "public_key": base64.b64encode(public_bytes).decode("ascii"),
+        "private_key": base64.b64encode(private_bytes).decode("ascii"),
+    }
+
+    IDENTITY_FILE.write_text(json.dumps(identity, indent=2))
+    return identity
+
+
+def load() -> dict | None:
+    """Load identity from disk.
+
+    Returns:
+        Identity dict or None if not found
+    """
+    if not IDENTITY_FILE.exists():
+        return None
+
+    return json.loads(IDENTITY_FILE.read_text())
+
+
+def get_signing_key() -> SigningKey:
+    """Get the signing key for the current identity."""
+    identity = load()
+    if not identity:
+        raise RuntimeError("No identity found. Run 'dagit init' first.")
+
+    private_bytes = base64.b64decode(identity["private_key"])
+    return SigningKey(private_bytes)
+
+
+def sign(message: bytes) -> bytes:
+    """Sign a message with the local identity.
+
+    Args:
+        message: Bytes to sign
+
+    Returns:
+        64-byte Ed25519 signature
+    """
+    signing_key = get_signing_key()
+    signed = signing_key.sign(message, encoder=RawEncoder)
+    return signed.signature
+
+
+def verify(message: bytes, signature: bytes, did: str) -> bool:
+    """Verify a signature against a DID.
+
+    Args:
+        message: Original message bytes
+        signature: 64-byte Ed25519 signature
+        did: did:key of the signer
+
+    Returns:
+        True if signature is valid
+    """
+    try:
+        public_bytes = _decode_did_key(did)
+        verify_key = VerifyKey(public_bytes)
+        verify_key.verify(message, signature)
+        return True
+    except (BadSignatureError, ValueError):
+        return False

pydagit-0.1.0/dagit/ipfs.py

@@ -0,0 +1,126 @@
+"""IPFS HTTP API wrapper for content-addressed storage."""
+
+import json
+from typing import Any
+
+import requests
+
+DEFAULT_API_URL = "http://localhost:5001/api/v0"
+
+
+class IPFSClient:
+    """Client for IPFS HTTP API."""
+
+    def __init__(self, api_url: str = DEFAULT_API_URL):
+        self.api_url = api_url.rstrip("/")
+
+    def _post(self, endpoint: str, **kwargs) -> requests.Response:
+        """Make a POST request to the IPFS API."""
+        url = f"{self.api_url}/{endpoint}"
+        response = requests.post(url, **kwargs)
+        response.raise_for_status()
+        return response
+
+    def add(self, content: str | bytes | dict) -> str:
+        """Add content to IPFS.
+
+        Args:
+            content: String, bytes, or dict (will be JSON-encoded)
+
+        Returns:
+            CID of the added content
+        """
+        if isinstance(content, dict):
+            content = json.dumps(content, separators=(",", ":"))
+        if isinstance(content, str):
+            content = content.encode("utf-8")
+
+        files = {"file": ("data", content)}
+        response = self._post("add", files=files)
+        result = response.json()
+        return result["Hash"]
+
+    def get(self, cid: str) -> bytes:
+        """Get content from IPFS by CID.
+
+        Args:
+            cid: Content identifier
+
+        Returns:
+            Raw bytes of the content
+        """
+        response = self._post("cat", params={"arg": cid})
+        return response.content
+
+    def get_json(self, cid: str) -> dict:
+        """Get and parse JSON content from IPFS.
+
+        Args:
+            cid: Content identifier
+
+        Returns:
+            Parsed JSON as dict
+        """
+        content = self.get(cid)
+        return json.loads(content)
+
+    def pin(self, cid: str) -> bool:
+        """Pin content to prevent garbage collection.
+
+        Args:
+            cid: Content identifier to pin
+
+        Returns:
+            True if pinned successfully
+        """
+        self._post("pin/add", params={"arg": cid})
+        return True
+
+    def is_available(self) -> bool:
+        """Check if IPFS daemon is available.
+
+        Returns:
+            True if IPFS API is reachable
+        """
+        try:
+            response = requests.post(f"{self.api_url}/id", timeout=2)
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+
+
+# Default client instance
+_client: IPFSClient | None = None
+
+
+def get_client() -> IPFSClient:
+    """Get the default IPFS client."""
+    global _client
+    if _client is None:
+        _client = IPFSClient()
+    return _client
+
+
+def add(content: str | bytes | dict) -> str:
+    """Add content to IPFS using default client."""
+    return get_client().add(content)
+
+
+def get(cid: str) -> bytes:
+    """Get content from IPFS using default client."""
+    return get_client().get(cid)
+
+
+def get_json(cid: str) -> dict:
+    """Get JSON content from IPFS using default client."""
+    return get_client().get_json(cid)
+
+
+def pin(cid: str) -> bool:
+    """Pin content using default client."""
+    return get_client().pin(cid)
+
+
+def is_available() -> bool:
+    """Check if IPFS is available using default client."""
+    return get_client().is_available()

pydagit-0.1.0/dagit/messages.py

@@ -0,0 +1,152 @@
+"""Post schema, signing, and verification for dagit messages."""
+
+import base64
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from . import identity, ipfs
+
+MESSAGE_VERSION = 2
+
+
+def create_post(
+    content: str,
+    refs: list[str] | None = None,
+    tags: list[str] | None = None,
+    post_type: str = "post",
+) -> dict:
+    """Create an unsigned post message.
+
+    Args:
+        content: Post content text
+        refs: List of CIDs this post references (optional)
+        tags: List of topic tags (optional)
+        post_type: Message type (default "post")
+
+    Returns:
+        Unsigned post dict
+    """
+    ident = identity.load()
+    if not ident:
+        raise RuntimeError("No identity found. Run 'dagit init' first.")
+
+    return {
+        "v": MESSAGE_VERSION,
+        "type": post_type,
+        "content": content,
+        "author": ident["did"],
+        "refs": refs or [],
+        "tags": tags or [],
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def _signing_payload(post: dict) -> bytes:
+    """Create the canonical signing payload for a post.
+
+    Excludes the signature field and uses deterministic JSON encoding.
+    """
+    # Create a copy without signature for signing
+    signing_dict = {k: v for k, v in post.items() if k != "signature"}
+    # Deterministic JSON: sorted keys, no whitespace
+    return json.dumps(signing_dict, sort_keys=True, separators=(",", ":")).encode(
+        "utf-8"
+    )
+
+
+def sign_post(post: dict) -> dict:
+    """Sign a post with the local identity.
+
+    Args:
+        post: Unsigned post dict
+
+    Returns:
+        Post dict with 'signature' field added
+    """
+    payload = _signing_payload(post)
+    signature = identity.sign(payload)
+    return {**post, "signature": base64.b64encode(signature).decode("ascii")}
+
+
+def verify_post(post: dict) -> bool:
+    """Verify a post's signature.
+
+    Args:
+        post: Post dict with 'signature' field
+
+    Returns:
+        True if signature is valid
+    """
+    if "signature" not in post:
+        return False
+
+    try:
+        signature = base64.b64decode(post["signature"])
+        payload = _signing_payload(post)
+        return identity.verify(payload, signature, post["author"])
+    except (KeyError, ValueError):
+        return False
+
+
+def serialize(post: dict) -> str:
+    """Serialize a post to JSON string.
+
+    Args:
+        post: Post dict
+
+    Returns:
+        JSON string (compact format for IPFS)
+    """
+    return json.dumps(post, separators=(",", ":"))
+
+
+def deserialize(data: str | bytes) -> dict:
+    """Deserialize a post from JSON.
+
+    Args:
+        data: JSON string or bytes
+
+    Returns:
+        Post dict
+    """
+    if isinstance(data, bytes):
+        data = data.decode("utf-8")
+    return json.loads(data)
+
+
+def publish(
+    content: str,
+    refs: list[str] | None = None,
+    tags: list[str] | None = None,
+) -> str:
+    """Create, sign, and publish a post to IPFS.
+
+    Args:
+        content: Post content text
+        refs: List of CIDs this post references (optional)
+        tags: List of topic tags (optional)
+
+    Returns:
+        CID of the published post
+    """
+    post = create_post(content, refs=refs, tags=tags)
+    signed = sign_post(post)
+    cid = ipfs.add(signed)
+    ipfs.pin(cid)
+    return cid
+
+
+def fetch(cid: str) -> tuple[dict, bool]:
+    """Fetch a post from IPFS and verify its signature.
+
+    Args:
+        cid: Content identifier of the post
+
+    Returns:
+        Tuple of (post dict, is_verified)
+    """
+    data = ipfs.get(cid)
+    post = deserialize(data)
+    verified = verify_post(post)
+    return post, verified

pydagit-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "pydagit"
+version = "0.1.0"
+description = "AI Agent Social Network on IPFS"
+requires-python = ">=3.10"
+dependencies = [
+    "rich>=13.0",
+    "click>=8.0",
+    "requests>=2.28",
+    "pynacl>=1.5",
+]
+
+[project.scripts]
+dagit = "dagit.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["dagit"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"