devin-devkit 0.1.0__py3-none-any.whl

devin_devkit/updater.py

@@ -0,0 +1,262 @@
+"""Update installed tools against the remote devkit manifest.
+
+The bundled ``manifest.json`` is a snapshot: every install spec is pinned to a
+PyPI version or a GitHub tarball SHA at export time, so installs never move by
+themselves. This module fetches the manifest published in the devin-devkit
+repository (always the newest registry export) and computes a plan to bring
+installed tools up to date.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any, Callable
+
+from devin_devkit.installer import DevKitError
+
+REMOTE_MANIFEST_URL = (
+    "https://raw.githubusercontent.com/Icaro0310/devin-devkit/main/"
+    "packages/devkit/src/devin_devkit/manifest.json"
+)
+FETCH_TIMEOUT = 15
+
+
+def fetch_remote_manifest(
+    url: str = REMOTE_MANIFEST_URL,
+    *,
+    opener: Callable[..., Any] | None = None,
+) -> dict[str, Any]:
+    """Download and parse the published manifest; raise DevKitError on failure."""
+    open_fn = opener or urllib.request.urlopen
+    try:
+        with open_fn(url, timeout=FETCH_TIMEOUT) as response:
+            data = json.loads(response.read().decode("utf-8"))
+    except (OSError, urllib.error.URLError, json.JSONDecodeError) as exc:
+        raise DevKitError(f"cannot fetch remote manifest: {exc}") from exc
+    if data.get("schema") != "devin-devkit-manifest/0.1":
+        raise DevKitError("remote manifest has an unexpected schema")
+    return data
+
+
+def installed_uv_tools(
+    runner: Callable[..., Any] = subprocess.run,
+) -> dict[str, str]:
+    """Return {package: version} from ``uv tool list``."""
+    try:
+        result = runner(
+            ["uv", "tool", "list"], capture_output=True, text=True, check=False
+        )
+    except OSError:
+        return {}
+    if result.returncode != 0:
+        return {}
+    installed: dict[str, str] = {}
+    for line in (result.stdout or "").splitlines():
+        if not line.strip() or line.startswith("-"):
+            continue
+        name, _, version = line.strip().partition(" ")
+        if name:
+            installed[name] = version.lstrip("v")
+    return installed
+
+
+try:
+    import tomllib
+except ImportError:  # Python 3.10 — declared as a conditional dependency
+    import tomli as tomllib
+
+
+def _uv_tools_dir() -> Path:
+    override = os.environ.get("UV_TOOL_DIR")
+    return (
+        Path(override)
+        if override
+        else Path.home() / ".local" / "share" / "uv" / "tools"
+    )
+
+
+def installed_uv_specs(
+    tools_dir: str | Path | None = None,
+) -> dict[str, str]:
+    """Return {package: installed requirement} parsed from uv receipts.
+
+    ``uv tool list`` reports only name and version; the per-tool
+    ``uv-receipt.toml`` also records the requirement, including the
+    source URL for non-PyPI installs. That lets the updater detect a
+    channel migration (git archive -> PyPI) even when the version number
+    did not change.
+    """
+    root = Path(tools_dir) if tools_dir else _uv_tools_dir()
+    specs: dict[str, str] = {}
+    if not root.is_dir():
+        return specs
+    for receipt in root.glob("*/uv-receipt.toml"):
+        try:
+            data = tomllib.loads(receipt.read_text(encoding="utf-8"))
+        except (OSError, tomllib.TOMLDecodeError):
+            continue
+        for req in data.get("tool", {}).get("requirements", []):
+            if not isinstance(req, dict):
+                continue
+            name = req.get("name")
+            if not name:
+                continue
+            specs[name] = req.get("url") or f"{name}{req.get('specifier', '')}"
+    return specs
+
+
+def _spec_channel(spec: str) -> str:
+    """Compare-key for install specs: PyPI installs collapse to 'pypi',
+    URL installs compare by exact URL."""
+    if re.match(r"(https?://|git\+)", spec):
+        return f"url:{spec}"
+    return "pypi"
+
+
+def installed_npm_tools(
+    runner: Callable[..., Any] = subprocess.run,
+) -> dict[str, str]:
+    """Return {package: version} from ``npm ls -g --depth=0 --json``."""
+    try:
+        result = runner(
+            ["npm", "ls", "--global", "--depth=0", "--json"],
+            capture_output=True, text=True, check=False,
+        )
+    except OSError:
+        return {}
+    try:
+        data = json.loads(result.stdout or "{}")
+    except json.JSONDecodeError:
+        return {}
+    return {
+        name: meta.get("version", "")
+        for name, meta in data.get("dependencies", {}).items()
+        if isinstance(meta, dict)
+    }
+
+
+def build_update_plan(
+    remote: dict[str, Any],
+    *,
+    installed: dict[str, str] | None = None,
+    installed_specs: dict[str, str] | None = None,
+    which: Callable[[str], str | None] = shutil.which,
+    runner: Callable[..., Any] = subprocess.run,
+    force: bool = False,
+) -> dict[str, Any]:
+    """Diff installed tools against the remote manifest.
+
+    ``installed`` maps package name to installed version; when None it is
+    discovered via ``uv tool list`` and ``npm ls -g``.
+    ``installed_specs`` maps package name to the requirement it was
+    installed from (uv receipts); when None it is discovered via
+    ``installed_uv_specs``. A same-version channel change (git archive
+    -> PyPI pin) plans a reinstall rather than reporting ``current``.
+    """
+    if installed is None:
+        installed = installed_uv_tools(runner)
+        installed.update(installed_npm_tools(runner))
+    if installed_specs is None:
+        installed_specs = installed_uv_specs()
+
+    actions: list[dict[str, Any]] = []
+    for tool in remote.get("tools", []):
+        tool_id = tool["id"]
+        manager = tool.get("manager")
+        if manager == "manual" or tool.get("status") == "manual":
+            continue
+        commands = tool.get("commands", [])
+        on_path = any(which(command) is not None for command in commands)
+        if tool["package"] not in installed and not on_path:
+            actions.append({"tool": tool_id, "action": "not-installed"})
+            continue
+        spec = tool.get("install_spec")
+        if not spec:
+            actions.append({"tool": tool_id, "action": "blocked", "detail": "missing install specification"})
+            continue
+        local_version = installed.get(tool["package"], "?")
+        remote_version = tool.get("version", "?")
+        if not force and local_version == remote_version:
+            installed_spec = installed_specs.get(tool["package"])
+            if (
+                manager == "uv"
+                and installed_spec is not None
+                and _spec_channel(installed_spec) != _spec_channel(spec)
+            ):
+                actions.append({
+                    "tool": tool_id,
+                    "action": "update",
+                    "from": local_version,
+                    "to": remote_version,
+                    "reason": "install source changed",
+                    "command": ["uv", "tool", "install", "--force", spec],
+                })
+            else:
+                actions.append({"tool": tool_id, "action": "current", "version": local_version})
+            continue
+        command = (
+            ["uv", "tool", "install", "--force", spec]
+            if manager == "uv"
+            else ["npm", "install", "--global", spec]
+        )
+        actions.append({
+            "tool": tool_id,
+            "action": "update",
+            "from": local_version,
+            "to": remote_version,
+            "command": command,
+        })
+    return {
+        "registry_version": remote.get("registry_version"),
+        "generated": remote.get("generated"),
+        "actions": actions,
+    }
+
+
+def apply_update_plan(
+    plan: dict[str, Any],
+    runner: Callable[..., Any] = subprocess.run,
+) -> dict[str, Any]:
+    updated: list[str] = []
+    failed: list[str] = []
+    for action in plan["actions"]:
+        if action["action"] != "update":
+            continue
+        try:
+            result = runner(action["command"], check=False)
+        except OSError:
+            result = None
+        if result is None or result.returncode:
+            failed.append(action["tool"])
+        else:
+            updated.append(action["tool"])
+    return {"updated": updated, "failed": failed}
+
+
+def freshness_hint(
+    manifest: dict[str, Any],
+    *,
+    opener: Callable[..., Any] | None = None,
+) -> str | None:
+    """One-line hint when the remote registry is newer than the bundled manifest.
+
+    Never raises: network or parse problems simply return None.
+    """
+    try:
+        remote = fetch_remote_manifest(opener=opener)
+    except DevKitError:
+        return None
+    local_version = manifest.get("registry_version", 0)
+    remote_version = remote.get("registry_version", 0)
+    if remote_version > local_version:
+        return (
+            f"registry v{remote_version} is available "
+            f"(bundled: v{local_version}); run 'devin-devkit update'"
+        )
+    return None

devin_devkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: devin-devkit
+Version: 0.1.0
+Summary: Install public Devin CLI profiles through uv
+Author: Icaro0310
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+<div align="center">
+
+<a href="https://github.com/Icaro0310/devin-devkit/actions/workflows/test-devkit.yml"><img src="https://github.com/Icaro0310/devin-devkit/actions/workflows/test-devkit.yml/badge.svg" alt="ci"/></a>
+
+<a href="https://scorecard.dev/viewer/?uri=github.com/Icaro0310/devin-devkit"><img src="https://api.scorecard.dev/projects/github.com/Icaro0310/devin-devkit/badge" alt="OpenSSF Scorecard"/></a>
+<a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT"/></a>
+<a href="https://www.python.org/"><img src="https://img.shields.io/badge/python-3.10%2B-blue" alt="Python 3.10+"/></a>
+<a href="https://github.com/Icaro0310/devin-devkit"><img src="https://img.shields.io/github/stars/Icaro0310/devin-devkit" alt="GitHub stars"/></a>
+<a href="https://github.com/Icaro0310/devin-devkit/commits/main"><img src="https://img.shields.io/github/last-commit/Icaro0310/devin-devkit" alt="Last commit"/></a>
+<a href="https://github.com/Icaro0310/awesome-devin"><img src="https://img.shields.io/badge/part%20of-devin--*-ecosystem-7c3aed" alt="devin-* ecosystem"/></a>
+<a href="https://github.com/Icaro0310/devin-devkit/issues"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen" alt="PRs welcome"/></a>
+</div>
+
+# devin-devkit
+
+> Unofficial community project. Not affiliated with, endorsed by, or sponsored by Cognition AI. Devin is a Cognition AI trademark.
+
+**[Linux](README.linux.md)** · **[Personal Windows](README.windows.md)** · **[Corporate Windows](README.corporate-windows.md)** · **[Compatibility](COMPATIBILITY.md)** · **[macOS status](README.macos.md)**
+
+Part of the [awesome-devin](https://github.com/Icaro0310/awesome-devin) ecosystem: the curated hub for the devin-* tools.
+
+`devin-devkit` turns the public `devin-powerups` registry into selectable installation profiles. It is an **installer/distribution tool**, not a meta-package: each Python app gets its own isolated `uv` environment, and the Node bridge uses npm separately.
+
+![devin-devkit demo: list, outdated, doctor check](assets/demo.gif)
+
+## Source → tools → profiles
+
+- `devin-powerups/registry.json` is the catalog and profile source of truth for the first-party `devin-*` tools, this separate DevKit distribution, the maintainer hub, and related artifacts.
+- `tools/export_devkit_manifest.py` builds this repo's bundled manifest from the registry, including artifact, interface, audience, platform and environment metadata. The exporter rejects private or unregistered tools and verifies immutable Git commit references.
+- `src/devin_devkit/cli.py` previews and installs the selected profile under an explicit execution environment. It does not edit Devin settings, inspect session databases, or install Slack/Obsidian/VM services.
+
+## Execution environments
+
+One `devin-devkit` distribution supports three environments. Linux and Personal Windows use the extended runtime: local execution plus optional delegated workloads through Devin VM or QwenPaw when the selected tool supports them. Corporate Windows is intentionally self-contained: local execution only, with no VM, QwenPaw, Slack dependency, external compute, or workload delegation.
+
+The installer defaults to `linux` on Linux and `personal-windows` on Windows. Corporate Windows is never inferred from the operating system; select it explicitly so restricted machines fail closed:
+
+```bash
+devin-devkit install qa --environment linux
+devin-devkit install qa --environment personal-windows
+devin-devkit install qa --environment corporate-windows
+```
+
+Environment entry points: [Linux](environments/linux/README.md) · [Personal Windows](environments/personal-windows/README.md) · [Corporate Windows](environments/corporate-windows/README.md).
+
+The generated [compatibility matrix](COMPATIBILITY.md) is rendered from `registry.json`; unsupported entries carry an explicit registry reason rather than guessed compatibility.
+
+## Profiles
+
+| Profile | Contents |
+|---|---|
+| `qa` | internals spec, QA pack, evals, metrics, doctor |
+| `evaluation` | internals spec, evals, metrics, synthetic task fixtures |
+| `security` | redact, bridge, janitor |
+| `memory` / `agent` | memory, graph, search, poordjaevin |
+| `operations` | backup, history, doctor, metrics, janitor, PM, orchestrator, switch and skill catalog |
+| `full` / `all` | every automatically installable profile tool; `devin-office` remains a manual source-only service |
+
+QwenPaw is an optional add-on and is not installed by these profiles. macOS is planned, not tested.
+
+## Use
+
+Install the current GitHub source archive or use a local checkout; the package has no runtime dependencies:
+
+```bash
+uv tool install "git+https://github.com/Icaro0310/devin-devkit.git#subdirectory=packages/devkit"
+```
+
+From a local checkout, use `uv tool install .`. Then inspect the available profiles and preview before applying:
+
+```bash
+devin-devkit profiles
+devin-devkit list
+devin-devkit install qa
+devin-devkit install qa --apply
+devin-devkit install full --apply
+```
+
+Install specs are pinned (PyPI versions or GitHub archive SHAs), so an install never drifts on its own. To move forward:
+
+```bash
+devin-devkit outdated          # which installed tools have newer pins
+devin-devkit update            # preview the update plan
+devin-devkit update --apply    # reinstall outdated tools
+devin-devkit update --force --apply   # reinstall everything
+```
+
+`outdated`/`update` read the manifest published in this repository, which a weekly workflow re-exports from the maintainer registry, so the pins are never more than about a week behind upstream.
+
+To run from a checkout without installing the DevKit itself:
+
+```bash
+uv run --project . python -m devin_devkit.cli install qa
+```
+
+After a PyPI package release, the installer can also be run with `uvx devin-devkit ...`.
+
+The manifest pins PyPI versions where available and GitHub source archives to immutable commit SHAs otherwise. Before it starts, the installer checks platform support, registry-declared environment compatibility, required managers, Node.js for `devin-bridge`, and existing command collisions. It never overwrites an existing command; commands already on `PATH` are reported as pre-existing but are not version-verified, and a partial collision blocks the profile before any installs run.
+
+## Runtime requirements
+
+- Python tools: Python 3.10 or newer, installed in isolated environments managed by `uv`.
+- `devin-bridge`: Node.js 20 or newer and npm. Its pinned GitHub archive is downloaded over HTTPS.
+- Current installable profiles do not need Git. Git is needed only for manual source checkouts such as `devin-office`; package archives use HTTPS.
+- Supported environments: Linux, Personal Windows and Corporate Windows. Linux and Personal Windows may use optional delegated runtime; Corporate Windows rejects registry entries that require external runtime, delegation or external integrations. macOS is planned but not claimed as tested.
+
+## Development and synchronization
+
+```bash
+uv run --extra dev pytest
+python ../devin-powerups/tools/validate_registry.py
+python ../devin-powerups/tools/export_devkit_manifest.py
+python ../devin-powerups/tools/export_devkit_manifest.py --check
+python ../devin-powerups/tools/render_catalog.py --check ../Icaro0310/README.md
+```
+
+The DevKit package has no runtime dependencies. New catalog entries and profiles belong in the registry; regenerate the manifest instead of hand-editing its generated copy. For local sibling development, install dependencies editably in a virtual environment (examples in the OS guides); keep relative file paths out of publishable package metadata.

devin_devkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+devin_devkit/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+devin_devkit/cli.py,sha256=d47vn96QAuW-inihysQ6PZnC_YoWjP1WVKGnMaBMuJE,6348
+devin_devkit/installer.py,sha256=4sD6jF4mhiXCRiHKHfR8MnS9igPMSow5ltRcpMGtvuc,9369
+devin_devkit/manifest.json,sha256=dkoeo9v3lS7st2h1e6KBWY5GPDhJZ5uvU5ptCVFmnoQ,32670
+devin_devkit/updater.py,sha256=Ula6hTPJul1LPd0pqcOzmd4iAKem3LMXHrrK_tC23TU,8916
+devin_devkit-0.1.0.dist-info/METADATA,sha256=LYBZ5Hfw3tYHR7pFbUYzrJu6XmAgzPAARgywlL69ZYI,7963
+devin_devkit-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+devin_devkit-0.1.0.dist-info/entry_points.txt,sha256=BGUJCma8kpI1LPWYzFy_I7IjFItBXV4BegYR_dWxOYg,55
+devin_devkit-0.1.0.dist-info/top_level.txt,sha256=a-JvTFjEDz6sJz_SmzJLF5pxXiqBNNyd-RtD0QxQGdI,13
+devin_devkit-0.1.0.dist-info/RECORD,,

devin_devkit-0.1.0.dist-info/WHEEL

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

devin_devkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devin-devkit = devin_devkit.cli:main

devin_devkit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devin_devkit