dryft 0.1.1__tar.gz

dryft-0.1.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: dryft
+Version: 0.1.1
+Summary: Dryft CLI and daemon — sync agent context with Dryft server
+Author: Dryft
+License: MIT
+Keywords: dryft,ai,agents,coordination,git
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: certifi
+
+# Dryft Python client
+
+Same CLI as the Node client, installable via **pip** per the PRD:
+
+```bash
+pip install dryft
+dryft init
+dryft start
+```
+
+From source (repo root):
+
+```bash
+pip install -e ./client-py
+```
+
+Commands: `init`, `start`, `stop`, `status`, `config`, `push-notify`. Implementation follows the same phases as the Node client in `client/`.

dryft-0.1.1/README.md

@@ -0,0 +1,17 @@
+# Dryft Python client
+
+Same CLI as the Node client, installable via **pip** per the PRD:
+
+```bash
+pip install dryft
+dryft init
+dryft start
+```
+
+From source (repo root):
+
+```bash
+pip install -e ./client-py
+```
+
+Commands: `init`, `start`, `stop`, `status`, `config`, `push-notify`. Implementation follows the same phases as the Node client in `client/`.

dryft-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dryft"
+version = "0.1.1"
+description = "Dryft CLI and daemon — sync agent context with Dryft server"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Dryft" }]
+dependencies = ["certifi"]
+keywords = ["dryft", "ai", "agents", "coordination", "git"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.scripts]
+dryft = "dryft.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+dryft = ["templates/*.dryft"]

dryft-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dryft-0.1.1/src/dryft/__init__.py

@@ -0,0 +1,3 @@
+"""Dryft CLI — sync agent context with Dryft server."""
+
+__version__ = "0.1.0"

dryft-0.1.1/src/dryft/api.py

@@ -0,0 +1,73 @@
+"""
+HTTP client for Dryft server: POST /context, GET /context/:projectId, POST /push-notify.
+"""
+
+import json
+import ssl
+import urllib.error
+import urllib.request
+from urllib.parse import quote
+
+try:
+    import certifi
+    _ssl_context = ssl.create_default_context(cafile=certifi.where())
+except ImportError:
+    _ssl_context = ssl.create_default_context()
+    # macOS Python often lacks system certs; fall back to unverified if needed
+    try:
+        urllib.request.urlopen("https://example.com", context=_ssl_context, timeout=5)
+    except ssl.SSLCertVerificationError:
+        _ssl_context = ssl.create_unverified_context()
+    except Exception:
+        pass
+
+
+def _base(base_url: str, path: str) -> str:
+    base_url = base_url.rstrip("/")
+    path = path if path.startswith("/") else f"/{path}"
+    return f"{base_url}{path}"
+
+
+def post_context(base_url: str, payload: dict) -> None:
+    url = _base(base_url, "/context")
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=data, method="POST")
+    req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, context=_ssl_context) as res:
+            if res.status >= 400:
+                raise RuntimeError(f"POST /context failed: {res.status} {res.read().decode()}")
+    except urllib.error.HTTPError as e:
+        body = e.read().decode() if e.fp else ""
+        raise RuntimeError(f"POST /context failed: {e.code} {body}") from e
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"POST /context failed: {e.reason}") from e
+
+
+def get_context(base_url: str, project_id: str) -> dict:
+    url = _base(base_url, f"/context/{quote(project_id, safe='')}")
+    req = urllib.request.Request(url, method="GET")
+    try:
+        with urllib.request.urlopen(req, context=_ssl_context) as res:
+            return json.loads(res.read().decode())
+    except urllib.error.HTTPError as e:
+        body = e.read().decode() if e.fp else ""
+        raise RuntimeError(f"GET /context failed: {e.code} {body}") from e
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"GET /context failed: {e.reason}") from e
+
+
+def post_push_notify(base_url: str, body: dict) -> None:
+    url = _base(base_url, "/push-notify")
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(url, data=data, method="POST")
+    req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, context=_ssl_context) as res:
+            if res.status >= 400:
+                raise RuntimeError(f"POST /push-notify failed: {res.status} {res.read().decode()}")
+    except urllib.error.HTTPError as e:
+        body_text = e.read().decode() if e.fp else ""
+        raise RuntimeError(f"POST /push-notify failed: {e.code} {body_text}") from e
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"POST /push-notify failed: {e.reason}") from e

dryft-0.1.1/src/dryft/cli.py

@@ -0,0 +1,201 @@
+"""
+Dryft CLI entry. Commands: init, start, stop, status, config, push-notify.
+Matches PRD §6.1 and §12.1.
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from . import api, config as config_mod
+from .init_ import run_init
+from . import daemon as daemon_mod
+
+
+def _cwd(args: argparse.Namespace) -> str:
+    return getattr(args, "cwd", None) or os.getcwd()
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    """Create .dryft/, context.md, intent.md, .gitignore; prompt for server URL and project id."""
+    try:
+        run_init(_cwd(args))
+        return 0
+    except SystemExit as e:
+        print(e, file=sys.stderr)
+        return 1
+
+
+def cmd_start(args: argparse.Namespace) -> int:
+    """Start the background daemon (polling + sync). Use --foreground to run in terminal."""
+    try:
+        daemon_mod.start_daemon(
+            cwd=_cwd(args),
+            foreground=getattr(args, "foreground", False),
+        )
+        return 0
+    except SystemExit as e:
+        print(e, file=sys.stderr)
+        return 1
+
+
+def cmd_stop(args: argparse.Namespace) -> int:
+    """Stop the daemon."""
+    daemon_mod.stop_daemon(_cwd(args))
+    return 0
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    """Show current sync status and any warnings."""
+    cwd = _cwd(args)
+    cfg = config_mod.load_config(cwd)
+    if not cfg:
+        print("Run dryft init first.", file=sys.stderr)
+        return 1
+    last_sync_path = Path(cwd) / ".dryft" / "last_sync.json"
+    try:
+        data = json.loads(last_sync_path.read_text(encoding="utf-8"))
+        if data.get("last_sync"):
+            print("Last sync:", data["last_sync"])
+        if data.get("error"):
+            print("Last error:", data["error"])
+    except (OSError, json.JSONDecodeError):
+        print("No sync recorded yet. Run dryft start to sync.")
+    try:
+        state = api.get_context(cfg["server_url"], cfg["project_id"])
+        devs = state.get("developers") or {}
+        others = [k for k in devs if k != cfg["developer_id"]]
+        if devs:
+            print("Other developers:", ", ".join(others) or "none")
+        warnings = state.get("warnings") or []
+        if warnings:
+            print("Warnings:", len(warnings))
+            for w in warnings:
+                print(" -", w.get("detail") or f"{w.get('file', '?')}: {', '.join(w.get('developers') or [])}")
+    except Exception as e:
+        print("Could not fetch server state:", e)
+    return 0
+
+
+def cmd_config(args: argparse.Namespace) -> int:
+    """View or edit configuration (server URL, developer id, poll interval)."""
+    cwd = _cwd(args)
+    cfg = config_mod.load_config(cwd)
+    if not cfg:
+        print("Run dryft init first.", file=sys.stderr)
+        return 1
+    sub = getattr(args, "config_args", []) or []  # e.g. ["set", "server_url", "http://..."]
+    if len(sub) >= 3 and sub[0] == "set" and sub[1] and sub[2] is not None:
+        key, value = sub[1], sub[2]
+        next_cfg = dict(cfg)
+        if key == "server_url":
+            next_cfg["server_url"] = value.rstrip("/")
+        elif key == "project_id":
+            next_cfg["project_id"] = value
+        elif key == "developer_id":
+            next_cfg["developer_id"] = value
+        elif key == "poll_interval_ms":
+            next_cfg["poll_interval_ms"] = int(value) or cfg.get("poll_interval_ms") or 60_000
+        else:
+            print("Unknown key. Use: server_url, project_id, developer_id, poll_interval_ms", file=sys.stderr)
+            return 1
+        config_mod.save_config(cwd, next_cfg)
+        print("Config updated.")
+        return 0
+    print("server_url:", cfg["server_url"])
+    print("project_id:", cfg["project_id"])
+    print("developer_id:", cfg["developer_id"])
+    print("poll_interval_ms:", cfg.get("poll_interval_ms") or 60_000)
+    return 0
+
+
+def cmd_push_notify(args: argparse.Namespace) -> int:
+    """Manually notify the other developer that you've pushed."""
+    cwd = _cwd(args)
+    cfg = config_mod.load_config(cwd)
+    if not cfg:
+        print("Run dryft init first.", file=sys.stderr)
+        return 1
+    try:
+        api.post_push_notify(
+            cfg["server_url"],
+            {"developer": cfg["developer_id"], "project_id": cfg["project_id"]},
+        )
+        print("Push notification sent.")
+        return 0
+    except Exception as e:
+        print("Push notify failed:", e, file=sys.stderr)
+        return 1
+
+
+def cmd_update(_args: argparse.Namespace) -> int:
+    """Upgrade Dryft client to the latest version (pip install --upgrade dryft)."""
+    import subprocess
+    print("Upgrading Dryft client to latest version...")
+    try:
+        code = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "dryft"],
+            check=False,
+        ).returncode
+        if code != 0:
+            print("Update failed. You can try manually: pip install --upgrade dryft", file=sys.stderr)
+            return 1
+        print("Dryft updated. Run 'dryft --help' to see commands.")
+        return 0
+    except FileNotFoundError:
+        print("Could not find pip. Try: pip install --upgrade dryft", file=sys.stderr)
+        return 1
+
+
+def print_help(_args: argparse.Namespace) -> int:
+    """Print usage."""
+    help_text = """Dryft CLI (Stage 1)
+Usage: dryft <command>
+
+Commands:
+  init         Initialize Dryft in the current repo
+  start       Start the background daemon
+  stop        Stop the daemon
+  status      Show sync status and warnings
+  config      View or edit config (server URL, developer id, poll interval)
+  push-notify Notify the other developer that you've pushed
+  update      Upgrade Dryft client to the latest version (pip install --upgrade dryft)
+
+Install: pip install dryft  (or npm install -g dryft for Node client)
+See REPO_STRUCTURE.md and the PRD for full details.
+"""
+    print(help_text)
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="dryft", description="Dryft — agent context sync")
+    parser.add_argument("--cwd", default=None, help="Working directory (default: current)")
+    subparsers = parser.add_subparsers(dest="command", help="Command")
+
+    for name, fn in [
+        ("init", cmd_init),
+        ("start", cmd_start),
+        ("stop", cmd_stop),
+        ("status", cmd_status),
+        ("config", cmd_config),
+        ("push-notify", cmd_push_notify),
+        ("update", cmd_update),
+    ]:
+        sub = subparsers.add_parser(name)
+        sub.set_defaults(func=fn)
+        if name == "start":
+            sub.add_argument("--foreground", action="store_true", help="Run daemon in foreground")
+        elif name == "config":
+            sub.add_argument("config_args", nargs="*", help="get | set key value")
+
+    args = parser.parse_args()
+    if getattr(args, "func", None) is None:
+        return print_help(args)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dryft-0.1.1/src/dryft/config.py

@@ -0,0 +1,55 @@
+"""
+Load/save .dryft/config.json and ensure .dryft directory exists.
+"""
+
+import json
+from pathlib import Path
+
+# PRD §8.3: default 5 seconds for near-real-time awareness
+DEFAULT_POLL_INTERVAL_MS = 5_000
+CONFIG_FILENAME = "config.json"
+DRYFT_DIR = ".dryft"
+
+
+def _config_path(cwd: str) -> Path:
+    return Path(cwd) / DRYFT_DIR / CONFIG_FILENAME
+
+
+def ensure_dryft_dir(cwd: str) -> str:
+    dir_path = Path(cwd) / DRYFT_DIR
+    dir_path.mkdir(parents=True, exist_ok=True)
+    return str(dir_path)
+
+
+def load_config(cwd: str) -> dict | None:
+    path = _config_path(cwd)
+    try:
+        raw = path.read_text(encoding="utf-8")
+        data = json.loads(raw)
+        if not data or not isinstance(data, dict):
+            return None
+        if not all(k in data and isinstance(data.get(k), str) for k in ("server_url", "project_id", "developer_id")):
+            return None
+        poll = data.get("poll_interval_ms")
+        if not isinstance(poll, (int, float)) or poll <= 0:
+            poll = DEFAULT_POLL_INTERVAL_MS
+        return {
+            "server_url": (data["server_url"] or "").rstrip("/"),
+            "project_id": data["project_id"],
+            "developer_id": data["developer_id"],
+            "poll_interval_ms": int(poll),
+        }
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def save_config(cwd: str, config: dict) -> None:
+    ensure_dryft_dir(cwd)
+    path = _config_path(cwd)
+    data = {
+        "server_url": config["server_url"],
+        "project_id": config["project_id"],
+        "developer_id": config["developer_id"],
+        "poll_interval_ms": config.get("poll_interval_ms") or DEFAULT_POLL_INTERVAL_MS,
+    }
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")

dryft-0.1.1/src/dryft/context.py

@@ -0,0 +1,176 @@
+"""
+Build context payload for POST and render/write .dryft/context.md from GET response.
+PRD §7.1: template with Last synced, Project, Last Activity, Guidelines, severity; §7.4: ~200 line cap.
+"""
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+CONTEXT_LINE_CAP = 200  # PRD §7.4, §17.4
+
+GUIDELINES_BLOCK = """
+## Guidelines for AI Agent
+
+### Before Starting Any Task
+- Read this entire file.
+- Check if any files you plan to modify are listed under "Currently Active Changes" or "Files They Plan to Modify Next."
+- If overlap exists, inform your developer immediately before proceeding.
+
+### If You Share a File With the Other Agent
+- Read "What they changed" to understand exactly which functions/sections they are modifying.
+- Work in DIFFERENT functions or sections of the same file where possible.
+- If you must modify the SAME function they are working on, STOP and inform your developer — this is a high-conflict risk.
+- Do not change function signatures, interfaces, or exports that the other agent's code depends on.
+
+### During Work
+- If this file updates with a new warning, pause and inform your developer.
+- If the other developer completes changes to files you depend on, suggest pulling latest.
+- Keep your .dryft/intent.md updated after every file modification so the other agent can see your progress.
+""".strip()
+
+
+def _time_ago(iso: str) -> str:
+    try:
+        then = datetime.fromisoformat(iso.replace("Z", "+00:00")).timestamp()
+        sec = int(datetime.now(timezone.utc).timestamp() - then)
+        if sec < 60:
+            return "just now"
+        if sec < 3600:
+            return f"{sec // 60} min ago"
+        if sec < 86400:
+            return f"{sec // 3600} h ago"
+        return f"{sec // 86400} d ago"
+    except (ValueError, TypeError):
+        return ""
+
+
+def build_payload(
+    developer: str,
+    git_changes: list[dict],
+    intent: dict | None,
+    project_id: str | None = None,
+) -> dict:
+    active_changes = [
+        {
+            "file": c["file"],
+            "functions_modified": c.get("functionsModified", []),
+            "change_type": c.get("changeType", "modification"),
+        }
+        for c in git_changes
+    ]
+    payload: dict[str, Any] = {
+        "developer": developer,
+        "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "active_changes": active_changes,
+    }
+    if intent and intent.get("dependencies"):
+        payload["dependencies_affected"] = intent["dependencies"]
+    if intent:
+        payload["intent"] = {}
+        if intent.get("plannedFiles"):
+            payload["intent"]["planned_files"] = intent["plannedFiles"]
+        if intent.get("currentTask"):
+            payload["intent"]["current_task"] = intent["currentTask"]
+        if intent.get("dependencies"):
+            payload["intent"]["dependencies"] = intent["dependencies"]
+    if project_id:
+        payload["project_id"] = project_id
+    return payload
+
+
+def render_context_md(server_state: dict, my_developer_id: str) -> str:
+    developers = server_state.get("developers") or {}
+    warnings = server_state.get("warnings") or []
+    now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+    project_id = server_state.get("project_id") or ""
+
+    lines = [
+        "# Dryft — Shared Development Context",
+        "",
+        f"> Last synced: {now}",
+    ]
+    if project_id:
+        lines.append(f"> Project: {project_id}")
+    lines.append("")
+
+    others = [(k, v) for k, v in developers.items() if k != my_developer_id]
+    if not others:
+        lines.append("> No other developers in context yet.")
+    else:
+        for dev_id, dev in others:
+            lines.append(f"## Other Developer Activity ({dev_id})")
+            lines.append("")
+            if dev.get("last_update"):
+                ago = _time_ago(dev["last_update"])
+                if ago:
+                    lines.append("### Last Activity")
+                    lines.append("")
+                    lines.append(f"{dev_id} last active — {ago}")
+                    lines.append("")
+            planned = dev.get("intent") or {}
+            if planned.get("current_task"):
+                lines.append("### Current Task")
+                lines.append("")
+                lines.append(str(planned["current_task"]))
+                lines.append("")
+            changes = dev.get("active_changes") or []
+            if changes:
+                lines.append("### Currently Active Changes")
+                lines.append("")
+                for c in changes:
+                    funcs = c.get("functions_modified") or []
+                    func_str = f" — {', '.join(funcs)}" if funcs else ""
+                    lines.append(f"- **{c.get('file', '?')}** — {c.get('change_type', 'change')}{func_str}")
+                    if c.get("summary"):
+                        lines.append(f"  - Why: {c['summary']}")
+                lines.append("")
+            planned_files = planned.get("planned_files") or []
+            if planned_files:
+                lines.append("### Files They Plan to Modify Next")
+                lines.append("")
+                for f in planned_files:
+                    lines.append(f"- {f}")
+                lines.append("")
+            deps = dev.get("dependencies_affected") or []
+            if deps:
+                lines.append("### Dependencies Affected")
+                lines.append("")
+                for d in deps:
+                    lines.append(f"- {d}")
+                lines.append("")
+    if warnings:
+        lines.append("---")
+        lines.append("")
+        lines.append("## Warnings")
+        lines.append("")
+        for w in warnings:
+            severity = "WARNING" if w.get("type") == "overlap" else "INFO"
+            detail = w.get("detail") or ", ".join(w.get("developers") or [])
+            lines.append(f"- **{severity}** — {w.get('file', '?')}: {detail}")
+        lines.append("")
+    last_push = server_state.get("last_push")
+    if last_push and last_push.get("at"):
+        lines.append("---")
+        lines.append("")
+        dev = last_push.get("developer")
+        lines.append(f"**Last push:** {last_push['at']}" + (f" by {dev}" if dev else ""))
+        lines.append("")
+    lines.append("---")
+    lines.append("")
+    lines.append(GUIDELINES_BLOCK)
+
+    out = "\n".join(lines)
+    line_list = out.split("\n")
+    if len(line_list) > CONTEXT_LINE_CAP:
+        kept = line_list[: CONTEXT_LINE_CAP - 2]
+        kept.append("")
+        kept.append("... (context truncated to 200 lines)")
+        return "\n".join(kept)
+    return out
+
+
+def write_context_file(cwd: str, content: str) -> None:
+    path = Path(cwd) / ".dryft" / "context.md"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")

dryft-0.1.1/src/dryft/daemon.py

@@ -0,0 +1,215 @@
+"""
+Background daemon: polling loop and sync cycle.
+Every N seconds: git detection + intent read → POST context → GET state → write context.md.
+PRD §6.2/§6.3: terminal notifications for overlap warnings and push.
+Phase 4: PID file for daemon lifecycle; stop kills the background process.
+"""
+
+import json
+import os
+import signal
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .api import get_context, post_context
+from .config import load_config
+from .context import build_payload, render_context_md, write_context_file
+from .git import detect_changes
+from .intent import read_intent
+
+LAST_SYNC_FILENAME = Path(".dryft") / "last_sync.json"
+DAEMON_PID_FILENAME = Path(".dryft") / "daemon.pid"
+
+
+def _read_last_sync(cwd: str) -> dict:
+    path = Path(cwd) / LAST_SYNC_FILENAME
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _run_sync(cwd: str) -> None:
+    config = load_config(cwd)
+    if not config:
+        return
+    previous = _read_last_sync(cwd)
+    git_changes = detect_changes(cwd)
+    intent = read_intent(cwd)
+    payload = build_payload(
+        config["developer_id"],
+        git_changes,
+        intent,
+        config.get("project_id"),
+    )
+    post_context(config["server_url"], payload)
+    state = get_context(config["server_url"], config["project_id"])
+    markdown = render_context_md(state, config["developer_id"])
+    write_context_file(cwd, markdown)
+
+    # PRD §6.3: terminal notification when overlap detected
+    warnings = state.get("warnings") or []
+    for w in warnings:
+        f = w.get("file", "?")
+        detail = w.get("detail", "")
+        print(f"⚠ Overlap detected on {f}: {detail}", file=sys.stderr)
+
+    # PRD §6.2 Step 9 / §10.3: terminal notification when other dev pushed
+    last_push: dict[str, Any] = state.get("last_push") or {}
+    if last_push.get("at") and last_push.get("developer") != config["developer_id"]:
+        seen = previous.get("last_push_seen") or {}
+        is_new = seen.get("at") != last_push.get("at") or seen.get("developer") != last_push.get("developer")
+        if is_new:
+            print(f"{last_push.get('developer')} pushed changes. Consider pulling before continuing.", file=sys.stderr)
+
+    next_data: dict[str, Any] = {
+        "last_sync": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "error": None,
+    }
+    if last_push.get("at"):
+        next_data["last_push_seen"] = {"at": last_push["at"], "developer": last_push.get("developer")}
+    else:
+        next_data["last_push_seen"] = previous.get("last_push_seen")
+
+    last_sync_path = Path(cwd) / LAST_SYNC_FILENAME
+    last_sync_path.write_text(json.dumps(next_data, indent=2), encoding="utf-8")
+
+
+def _run_sync_and_log(cwd: str) -> None:
+    last_sync_path = Path(cwd) / LAST_SYNC_FILENAME
+    try:
+        _run_sync(cwd)
+    except Exception as e:
+        msg = str(e)
+        try:
+            last_sync_path.write_text(
+                json.dumps(
+                    {"last_sync": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), "error": msg},
+                    indent=2,
+                ),
+                encoding="utf-8",
+            )
+        except OSError:
+            pass
+        print("Dryft sync error:", msg, file=sys.stderr)
+
+
+def _pid_path(cwd: str) -> Path:
+    return Path(cwd) / DAEMON_PID_FILENAME
+
+
+def _remove_pid_file(cwd: str) -> None:
+    try:
+        _pid_path(cwd).unlink()
+    except OSError:
+        pass
+
+
+def run_daemon_loop(
+    *,
+    cwd: str | None = None,
+    poll_interval_ms: int | None = None,
+) -> None:
+    """Run the sync loop in the current process (used by --foreground)."""
+    import time
+
+    cwd = cwd or str(Path.cwd())
+    if isinstance(cwd, Path):
+        cwd = str(cwd)
+    config = load_config(cwd)
+    if not config:
+        raise SystemExit("Run dryft init first.")
+    interval_ms = poll_interval_ms or config.get("poll_interval_ms") or 5_000
+    interval_sec = interval_ms / 1000.0
+
+    def shutdown(*_args: object) -> None:
+        _remove_pid_file(cwd)
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, shutdown)
+    signal.signal(signal.SIGTERM, shutdown)
+
+    _run_sync_and_log(cwd)
+    print(f"Dryft daemon running. Syncing every {interval_sec:.0f} s. Ctrl+C to stop.")
+    try:
+        while True:
+            time.sleep(interval_sec)
+            _run_sync_and_log(cwd)
+    except KeyboardInterrupt:
+        shutdown()
+
+
+def start_daemon(
+    *,
+    cwd: str | None = None,
+    poll_interval_ms: int | None = None,
+    foreground: bool = False,
+) -> None:
+    cwd = cwd or str(Path.cwd())
+    if isinstance(cwd, Path):
+        cwd = str(cwd)
+
+    if foreground:
+        run_daemon_loop(cwd=cwd, poll_interval_ms=poll_interval_ms)
+        return
+
+    config = load_config(cwd)
+    if not config:
+        raise SystemExit("Run dryft init first.")
+
+    pid_path = _pid_path(cwd)
+    if pid_path.exists():
+        try:
+            existing_pid = int(pid_path.read_text().strip())
+            os.kill(existing_pid, 0)
+            print("Daemon already running (PID", existing_pid, "). Use 'dryft stop' first.", file=sys.stderr)
+            sys.exit(1)
+        except (ValueError, ProcessLookupError, OSError):
+            pid_path.unlink(missing_ok=True)
+
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "dryft.cli", "start", "--foreground"],
+        cwd=cwd,
+        start_new_session=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    if proc.pid is not None:
+        pid_path.parent.mkdir(parents=True, exist_ok=True)
+        pid_path.write_text(str(proc.pid), encoding="utf-8")
+        print("Dryft daemon started in background (PID", proc.pid, "). Use 'dryft stop' to stop.")
+    else:
+        print("Failed to start daemon.", file=sys.stderr)
+        sys.exit(1)
+
+
+def stop_daemon(cwd: str | None = None) -> None:
+    cwd = cwd or str(Path.cwd())
+    if isinstance(cwd, Path):
+        cwd = str(cwd)
+    pid_path = _pid_path(cwd)
+    try:
+        pid_str = pid_path.read_text(encoding="utf-8").strip()
+    except OSError:
+        print("Daemon not running (no PID file).")
+        return
+    try:
+        pid = int(pid_str)
+    except ValueError:
+        print("Daemon not running (invalid PID file).")
+        pid_path.unlink(missing_ok=True)
+        return
+    try:
+        os.kill(pid, signal.SIGTERM)
+        pid_path.unlink(missing_ok=True)
+        print("Dryft daemon stopped (PID", pid, ").")
+    except ProcessLookupError:
+        pid_path.unlink(missing_ok=True)
+        print("Daemon was not running (stale PID file removed).")
+    except OSError as e:
+        print("Could not stop daemon:", e, file=sys.stderr)
+        sys.exit(1)

dryft-0.1.1/src/dryft/git.py

@@ -0,0 +1,87 @@
+"""
+Git-based change detection: git status, git diff, function/class extraction from diffs.
+"""
+
+import re
+import subprocess
+from typing import TypedDict
+
+
+class GitChange(TypedDict):
+    file: str
+    changeType: str
+    functionsModified: list[str]
+
+
+FUNCTION_REGEXES = [
+    re.compile(r"^\s*(?:function|async\s+function)\s+(\w+)\s*\("),
+    re.compile(r"^\s*class\s+(\w+)"),
+    re.compile(r"^\s*def\s+(\w+)\s*\("),
+    re.compile(r"^\s*(?:async\s+)?def\s+(\w+)\s*\("),
+]
+
+
+def _extract_functions_from_diff_hunk(hunk_lines: list[str]) -> list[str]:
+    names: set[str] = set()
+    for line in hunk_lines:
+        if line.startswith("+") and not line.startswith("+++"):
+            content = line[1:]
+            for pattern in FUNCTION_REGEXES:
+                m = pattern.search(content)
+                if m and m.lastindex:
+                    names.add(m.group(1))
+    return list(names)
+
+
+def _get_change_type(x: str, y: str) -> str:
+    if x == "D" or y == "D":
+        return "deleted"
+    if x == "A" or x == "?" or y == "?":
+        return "new_file"
+    return "modification"
+
+
+def detect_changes(cwd: str) -> list[GitChange]:
+    try:
+        r = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+        )
+        if r.returncode != 0:
+            return []
+        out = r.stdout or ""
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return []
+    lines = [s for s in out.strip().split("\n") if s]
+    results: list[GitChange] = []
+    for line in lines:
+        xy = line[:2]
+        file_path = line[3:].strip()
+        if not file_path:
+            continue
+        x, y = xy[0], xy[1]
+        change_type = _get_change_type(x, y)
+        functions_modified: list[str] = []
+        try:
+            r = subprocess.run(
+                ["git", "diff", "HEAD", "--", file_path],
+                capture_output=True,
+                text=True,
+                cwd=cwd,
+            )
+            diff_out = r.stdout or ""
+            added_lines = [l for l in diff_out.split("\n") if l.startswith("+")]
+            functions_modified = _extract_functions_from_diff_hunk(added_lines)
+            if not functions_modified and change_type in ("modification", "new_file"):
+                functions_modified = ["(whole file)"]
+        except (subprocess.SubprocessError, FileNotFoundError):
+            if change_type == "new_file":
+                functions_modified = ["(whole file)"]
+        results.append({
+            "file": file_path,
+            "changeType": change_type,
+            "functionsModified": functions_modified,
+        })
+    return results

dryft-0.1.1/src/dryft/init_.py

@@ -0,0 +1,141 @@
+"""
+dryft init: create .dryft/, context.md, intent.md, .gitignore, inject agent templates, save config.
+"""
+
+import os
+from pathlib import Path
+from typing import Literal
+
+from .config import ensure_dryft_dir, save_config
+
+DRYFT_DIR = ".dryft"
+DRYFT_BLOCK_MARKER = "## Dryft Integration"
+
+
+def _read_template(name: str) -> str:
+    from importlib.resources import files
+    raw = files("dryft").joinpath("templates", name).read_text(encoding="utf-8")
+    return _strip_comment_first_line(raw).strip()
+
+
+def _strip_comment_first_line(content: str) -> str:
+    trimmed = content.lstrip()
+    if trimmed.startswith("<!--") and "-->" in trimmed:
+        after = trimmed[trimmed.index("-->") + 3 :].lstrip()
+        return after
+    return trimmed
+
+
+def _inject_into_file(cwd: str, target_filename: str, block: str) -> Literal["injected", "skipped", "created"]:
+    target = Path(cwd) / target_filename
+    existing = ""
+    try:
+        existing = target.read_text(encoding="utf-8")
+    except OSError:
+        pass
+    if DRYFT_BLOCK_MARKER in existing:
+        return "skipped"
+    new_content = f"{existing.rstrip()}\n\n{block}" if existing else block
+    target.write_text(new_content, encoding="utf-8")
+    return "injected" if existing else "created"
+
+
+INITIAL_CONTEXT_MD = """# Dryft — Shared Development Context
+
+> Not yet synced.
+"""
+
+INTENT_TEMPLATE = """# Intent
+
+Agent-declared plan and active work. Update this file so the other developer's agent can avoid overlap.
+
+**Agent:** Update the sections below when you start a task, when you change files, and when you finish a task.
+
+## Current Task
+
+(Describe what you're working on.)
+
+## Planned Files
+
+(Files you plan to modify next — one per line or bullet.)
+
+## Dependencies
+
+(Files or modules your work depends on.)
+
+## Active Changes
+
+(After modifying files: list functions/sections you changed.)
+
+## Notes
+
+(Optional.)
+"""
+
+
+def _get_default_developer_id() -> str:
+    return (
+        os.environ.get("DRYFT_DEVELOPER_ID")
+        or os.environ.get("USER")
+        or os.environ.get("USERNAME")
+        or (os.getlogin() if hasattr(os, "getlogin") else "developer")
+    )
+
+
+def run_init(cwd: str) -> None:
+    ensure_dryft_dir(cwd)
+    base = Path(cwd) / DRYFT_DIR
+
+    (base / "context.md").write_text(INITIAL_CONTEXT_MD, encoding="utf-8")
+    (base / "intent.md").write_text(INTENT_TEMPLATE, encoding="utf-8")
+
+    gitignore = Path(cwd) / ".gitignore"
+    try:
+        content = gitignore.read_text(encoding="utf-8")
+        if ".dryft" not in content:
+            addition = "\n.dryft/\n" if content.endswith("\n") else "\n.dryft/\n"
+            gitignore.write_text(content + addition, encoding="utf-8")
+    except FileNotFoundError:
+        gitignore.write_text(".dryft/\n", encoding="utf-8")
+
+    env_url = (os.environ.get("DRYFT_SERVER_URL") or "").strip()
+    env_project = (os.environ.get("DRYFT_PROJECT_ID") or "").strip()
+    default_dev = _get_default_developer_id()
+    if env_url and env_project:
+        server_url = env_url.rstrip("/")
+        project_id = env_project
+        developer_id = (os.environ.get("DRYFT_DEVELOPER_ID") or "").strip() or default_dev
+    else:
+        server_url = (
+            input("Server URL (e.g. https://your-app.railway.app) [{}]: ".format(env_url)).strip() or env_url or ""
+        ).rstrip("/")
+        project_id = input("Project ID [{}]: ".format(env_project)).strip() or env_project or ""
+        developer_id = (
+            input("Your developer ID [{}]: ".format(default_dev)).strip() or default_dev
+        )
+
+    if not server_url or not project_id:
+        raise SystemExit("Server URL and Project ID are required. Re-run dryft config to set them.")
+
+    config = {
+        "server_url": server_url.rstrip("/"),
+        "project_id": project_id,
+        "developer_id": developer_id or _get_default_developer_id(),
+        "poll_interval_ms": 5_000,
+    }
+    save_config(cwd, config)
+
+    claude_block = _read_template("CLAUDE.md.dryft")
+    cursorrules_block = _read_template("cursorrules.dryft")
+    claude_result = _inject_into_file(cwd, "CLAUDE.md", claude_block)
+    cursor_result = _inject_into_file(cwd, ".cursorrules", cursorrules_block)
+
+    print("Dryft initialized in", base)
+    if claude_result in ("injected", "created"):
+        print("Dryft block added to CLAUDE.md")
+    elif claude_result == "skipped":
+        print("CLAUDE.md already contains Dryft integration (unchanged).")
+    if cursor_result in ("injected", "created"):
+        print("Dryft block added to .cursorrules")
+    elif cursor_result == "skipped":
+        print(".cursorrules already contains Dryft integration (unchanged).")

dryft-0.1.1/src/dryft/intent.py

@@ -0,0 +1,62 @@
+"""
+Read and parse .dryft/intent.md (agent-declared plan, expected files, dependencies).
+"""
+
+import re
+from pathlib import Path
+from typing import TypedDict
+
+INTENT_FILENAME = Path(".dryft") / "intent.md"
+
+
+def _parse_list_lines(text: str) -> list[str]:
+    out = []
+    for line in text.split("\n"):
+        line = re.sub(r"^\s*[-*]\s+", "", re.sub(r"^\s*\d+\.\s*", "", line)).strip()
+        if line:
+            out.append(line)
+    return out
+
+
+def _extract_section(content: str, heading: str) -> str:
+    pattern = re.compile(
+        r"##\s+" + re.escape(heading) + r"\s*\n([\s\S]*?)(?=##\s|$)",
+        re.IGNORECASE,
+    )
+    m = pattern.search(content)
+    return m.group(1).strip() if m else ""
+
+
+class IntentData(TypedDict, total=False):
+    currentTask: str
+    plannedFiles: list[str]
+    dependencies: list[str]
+    activeChanges: str
+    notes: str
+
+
+def read_intent(cwd: str) -> IntentData | None:
+    path = Path(cwd) / INTENT_FILENAME
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    current_task = _extract_section(content, "Current Task")
+    planned_files_text = _extract_section(content, "Planned Files")
+    dependencies_text = _extract_section(content, "Dependencies")
+    active_changes = _extract_section(content, "Active Changes")
+    notes = _extract_section(content, "Notes")
+    planned = _parse_list_lines(planned_files_text)
+    deps = _parse_list_lines(dependencies_text)
+    out: IntentData = {}
+    if current_task:
+        out["currentTask"] = current_task
+    if planned:
+        out["plannedFiles"] = planned
+    if deps:
+        out["dependencies"] = deps
+    if active_changes:
+        out["activeChanges"] = active_changes
+    if notes:
+        out["notes"] = notes
+    return out if out else None

dryft-0.1.1/src/dryft/templates/CLAUDE.md.dryft

@@ -0,0 +1,30 @@
+<!-- Insert this block into your project's CLAUDE.md for Dryft integration. -->
+
+## Dryft Integration
+
+**CRITICAL:** You MUST read .dryft/context.md before starting and MUST update .dryft/intent.md after any file change and when a task is complete. Do not skip these steps.
+
+BEFORE starting any task:
+1. Read .dryft/context.md to understand what the other developer's AI is working on.
+2. If your task is the same or equivalent to another developer's task in context.md (their "Current Task" or work they list in "Currently Active Changes" / "Files They Plan to Modify Next" / or marked "Complete"): (a) Check whether the files, directories, or functions that work would touch exist locally. (b) If they exist locally — do NOT redo the work; tell your developer the task appears already done. (c) If they do NOT exist locally — do NOT implement. Dryft is preventing duplicate work: the changes are completed elsewhere but not on your branch. Tell your developer: "The other developer's work for this task is marked complete, but the relevant files don't exist on your local branch yet. Update your local branch (e.g. git pull) to get their changes, then you can proceed or ask me again."
+3. Check "Currently Active Changes" AND "Files They Plan to Modify Next" for overlap with your planned files.
+4. If overlap exists, tell your developer immediately before proceeding.
+5. Write your plan to .dryft/intent.md — include your task, plan, expected files, and dependencies.
+
+AFTER modifying any file:
+1. Update .dryft/intent.md "Active Changes" section with what you changed — functions added/modified, exports changed, interfaces altered.
+2. This is critical — the other agent relies on this to avoid conflicts.
+
+IF you share a file with the other agent:
+1. Read context.md to see exactly WHICH functions/sections they are modifying.
+2. Work in DIFFERENT functions or sections of the same file.
+3. If you must modify the SAME function, STOP and tell your developer — this is a merge conflict risk.
+4. Do NOT change function signatures, interfaces, or exports that the other agent depends on.
+
+DURING work:
+1. Re-read .dryft/context.md periodically (at least before each new file modification).
+2. If context.md shows a new warning, pause and inform your developer.
+3. If the other developer completes changes to files you depend on, suggest pulling latest.
+
+AFTER completing a task:
+1. Update .dryft/intent.md to mark the task as complete.

dryft-0.1.1/src/dryft/templates/cursorrules.dryft

@@ -0,0 +1,30 @@
+<!-- Insert this block into your project's .cursorrules for Dryft integration. -->
+
+## Dryft Integration
+
+**CRITICAL:** You MUST read .dryft/context.md before starting and MUST update .dryft/intent.md after any file change and when a task is complete. Do not skip these steps.
+
+BEFORE starting any task:
+1. Read .dryft/context.md to understand what the other developer's AI is working on.
+2. If your task is the same or equivalent to another developer's task in context.md (their "Current Task" or work they list in "Currently Active Changes" / "Files They Plan to Modify Next" / or marked "Complete"): (a) Check whether the files, directories, or functions that work would touch exist locally. (b) If they exist locally — do NOT redo the work; tell your developer the task appears already done. (c) If they do NOT exist locally — do NOT implement. Dryft is preventing duplicate work: the changes are completed elsewhere but not on your branch. Tell your developer: "The other developer's work for this task is marked complete, but the relevant files don't exist on your local branch yet. Update your local branch (e.g. git pull) to get their changes, then you can proceed or ask me again."
+3. Check "Currently Active Changes" AND "Files They Plan to Modify Next" for overlap with your planned files.
+4. If overlap exists, tell your developer immediately before proceeding.
+5. Write your plan to .dryft/intent.md — include your task, plan, expected files, and dependencies.
+
+AFTER modifying any file:
+1. Update .dryft/intent.md "Active Changes" section with what you changed — functions added/modified, exports changed, interfaces altered.
+2. This is critical — the other agent relies on this to avoid conflicts.
+
+IF you share a file with the other agent:
+1. Read context.md to see exactly WHICH functions/sections they are modifying.
+2. Work in DIFFERENT functions or sections of the same file.
+3. If you must modify the SAME function, STOP and tell your developer — this is a merge conflict risk.
+4. Do NOT change function signatures, interfaces, or exports that the other agent depends on.
+
+DURING work:
+1. Re-read .dryft/context.md periodically (at least before each new file modification).
+2. If context.md shows a new warning, pause and inform your developer.
+3. If the other developer completes changes to files you depend on, suggest pulling latest.
+
+AFTER completing a task:
+1. Update .dryft/intent.md to mark the task as complete.

dryft-0.1.1/src/dryft.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: dryft
+Version: 0.1.1
+Summary: Dryft CLI and daemon — sync agent context with Dryft server
+Author: Dryft
+License: MIT
+Keywords: dryft,ai,agents,coordination,git
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: certifi
+
+# Dryft Python client
+
+Same CLI as the Node client, installable via **pip** per the PRD:
+
+```bash
+pip install dryft
+dryft init
+dryft start
+```
+
+From source (repo root):
+
+```bash
+pip install -e ./client-py
+```
+
+Commands: `init`, `start`, `stop`, `status`, `config`, `push-notify`. Implementation follows the same phases as the Node client in `client/`.

dryft-0.1.1/src/dryft.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/dryft/__init__.py
+src/dryft/api.py
+src/dryft/cli.py
+src/dryft/config.py
+src/dryft/context.py
+src/dryft/daemon.py
+src/dryft/git.py
+src/dryft/init_.py
+src/dryft/intent.py
+src/dryft.egg-info/PKG-INFO
+src/dryft.egg-info/SOURCES.txt
+src/dryft.egg-info/dependency_links.txt
+src/dryft.egg-info/entry_points.txt
+src/dryft.egg-info/requires.txt
+src/dryft.egg-info/top_level.txt
+src/dryft/templates/CLAUDE.md.dryft
+src/dryft/templates/cursorrules.dryft

dryft-0.1.1/src/dryft.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dryft-0.1.1/src/dryft.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dryft = dryft.cli:main

dryft-0.1.1/src/dryft.egg-info/requires.txt

@@ -0,0 +1 @@
+certifi

dryft-0.1.1/src/dryft.egg-info/top_level.txt

@@ -0,0 +1 @@
+dryft