devin-graph 0.1.0__py3-none-any.whl

devin_graph/identity.py

@@ -0,0 +1,126 @@
+"""Opaque machine identity + profile for provenance metadata.
+
+Artifacts written by this tool carry ``machine_id`` + ``profile`` so output
+produced on different machines (e.g. personal vs corporate) can be told
+apart — without leaking hostnames, usernames or MAC addresses.
+
+Resolution order:
+
+- ``machine_id``: the ``DEVIN_MACHINE_ID`` env var wins; otherwise a random
+  ``secrets.token_hex(8)`` persisted at
+  ``<devin-config-dir>/.devin-ecosystem/machine-id`` (mode 0600, created on
+  first use). Never derived from hostname, username or hardware ids.
+- ``profile``: the ``DEVIN_ECOSYSTEM_PROFILE`` env var
+  (``"corporate"`` | ``"personal"``), else ``devin-profile.json`` in the
+  Devin config dir, else ``"corporate"`` — fail-closed.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import secrets
+import sys
+from pathlib import Path
+
+MACHINE_ID_ENV = "DEVIN_MACHINE_ID"
+PROFILE_ENV = "DEVIN_ECOSYSTEM_PROFILE"
+CONFIG_DIR_ENV = "DEVIN_CONFIG_DIR"
+ECOSYSTEM_DIRNAME = ".devin-ecosystem"
+MACHINE_ID_FILENAME = "machine-id"
+PROFILE_FILENAME = "devin-profile.json"
+PROFILES = ("corporate", "personal")
+DEFAULT_PROFILE = "corporate"  # fail-closed
+
+
+def devin_config_dir(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> Path:
+    """Devin Desktop's config root (``%APPDATA%/Devin``, ``~/.config/Devin``).
+
+    Same rule devin-backup's ``default_config_dir`` uses, so every devin-*
+    tool resolves the same ``.devin-ecosystem/machine-id`` on one machine.
+    """
+    env = os.environ if environ is None else environ
+    plat = sys.platform if platform is None else platform
+    override = env.get(CONFIG_DIR_ENV)
+    if override:
+        return Path(override).expanduser()
+    if plat == "nt" or plat.startswith("win"):
+        appdata = env.get("APPDATA")
+        if appdata:
+            return Path(appdata) / "Devin"
+        return Path.home() / "AppData" / "Roaming" / "Devin"
+    if plat == "darwin":
+        return Path.home() / "Library" / "Application Support" / "devin"
+    config_home = Path(env.get("XDG_CONFIG_HOME") or Path.home() / ".config")
+    candidates = [config_home / "Devin", config_home / "devin"]
+    return next(
+        (c for c in candidates if (c / "User").is_dir()), candidates[0]
+    )
+
+
+def machine_id(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> str:
+    """Stable opaque id for this machine (16 hex chars)."""
+    env = os.environ if environ is None else environ
+    override = (env.get(MACHINE_ID_ENV) or "").strip()
+    if override:
+        return override
+    path = (
+        devin_config_dir(env, platform)
+        / ECOSYSTEM_DIRNAME
+        / MACHINE_ID_FILENAME
+    )
+    try:
+        existing = path.read_text(encoding="utf-8").strip()
+    except OSError:
+        existing = ""
+    if existing:
+        return existing
+    value = secrets.token_hex(8)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(value + "\n", encoding="utf-8")
+    try:
+        path.chmod(0o600)
+    except OSError:  # filesystems without POSIX modes
+        pass
+    return value
+
+
+def _profile_from_file(
+    env: dict[str, str], plat: str
+) -> str | None:
+    path = devin_config_dir(env, plat) / PROFILE_FILENAME
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    raw = data.get("profile") if isinstance(data, dict) else data
+    raw = str(raw or "").strip().lower()
+    return raw if raw in PROFILES else None
+
+
+def profile(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> str:
+    """``"corporate"`` | ``"personal"`` — unknown values fail closed."""
+    env = os.environ if environ is None else environ
+    raw = (env.get(PROFILE_ENV) or "").strip().lower()
+    if raw in PROFILES:
+        return raw
+    if raw:
+        return DEFAULT_PROFILE  # set but unrecognized — fail closed
+    plat = sys.platform if platform is None else platform
+    return _profile_from_file(env, plat) or DEFAULT_PROFILE
+
+
+def provenance(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> dict[str, str]:
+    """``{"machine_id": ..., "profile": ...}`` for embedding in outputs."""
+    return {
+        "machine_id": machine_id(environ, platform),
+        "profile": profile(environ, platform),
+    }

devin_graph/paths.py

@@ -0,0 +1,92 @@
+"""Default locations for Devin's local session database.
+
+Linux uses ``$XDG_DATA_HOME/devin/cli/sessions.db`` (default
+``~/.local/share/devin/cli/sessions.db``), with older config-dir candidates as
+fallbacks.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+APP_DIRNAME = "devin"
+SESSIONS_DB_RELPATH = ("cli", "sessions.db")
+
+
+def _roots(environ: dict[str, str], platform: str) -> list[Path]:
+    if platform.startswith("win"):
+        roots = []
+        if environ.get("APPDATA"):
+            roots.append(Path(environ["APPDATA"]))
+        roots.append(Path.home() / "AppData" / "Roaming")
+    elif platform == "darwin":
+        roots = [Path.home() / "Library" / "Application Support"]
+    else:
+        roots = [
+            Path(environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share"),
+            Path(environ.get("XDG_CONFIG_HOME") or Path.home() / ".config"),
+            Path.home(),
+        ]
+    return list(dict.fromkeys(roots))
+
+
+def sessions_db_candidates(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> list[Path]:
+    """Candidate paths for the CLI ``sessions.db``, newest layout first."""
+    env = os.environ if environ is None else environ
+    plat = sys.platform if platform is None else platform
+    return [
+        root.joinpath(APP_DIRNAME, *SESSIONS_DB_RELPATH)
+        for root in _roots(env, plat)
+    ]
+
+
+VSCDB_RELPATH = ("User", "globalStorage", "state.vscdb")
+
+
+def state_vscdb_candidates(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> list[Path]:
+    """Candidate paths for the GUI ``state.vscdb`` (Electron storage)."""
+    env = os.environ if environ is None else environ
+    plat = sys.platform if platform is None else platform
+    if plat.startswith("win"):
+        roots = []
+        if env.get("APPDATA"):
+            roots.append(Path(env["APPDATA"]))
+        roots.append(Path.home() / "AppData" / "Roaming")
+    elif plat == "darwin":
+        roots = [Path.home() / "Library" / "Application Support"]
+    else:
+        roots = [
+            Path(env.get("XDG_CONFIG_HOME") or Path.home() / ".config"),
+            Path.home(),
+        ]
+    names = ("Devin", "devin")
+    return [
+        r.joinpath(n, *VSCDB_RELPATH)
+        for r in dict.fromkeys(roots) for n in names
+    ]
+
+
+def default_state_vscdb(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> Path | None:
+    """First existing state.vscdb candidate, or ``None``."""
+    for candidate in state_vscdb_candidates(environ=environ, platform=platform):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def default_sessions_db(
+    environ: dict[str, str] | None = None, platform: str | None = None
+) -> Path | None:
+    """First existing candidate, or ``None`` when no store is present."""
+    for candidate in sessions_db_candidates(environ=environ, platform=platform):
+        if candidate.is_file():
+            return candidate
+    return None

devin_graph/query.py

@@ -0,0 +1,234 @@
+"""Canned queries over a built ``graph.db``.
+
+Matching is forgiving: exact key first, then case-insensitive, then suffix
+(so ``src/app.py`` finds ``/repo/alpha/src/app.py``). All functions return
+plain JSON-ready dicts.
+"""
+
+from __future__ import annotations
+
+from itertools import combinations
+
+from devin_graph.extract import normalize_path
+
+
+def _session_dict(gs, node) -> dict:
+    project = None
+    for e in gs.out_edges(node.id):
+        if e.kind == "runs_in":
+            project = e.dst.split(":", 1)[1]
+    return {
+        "id": node.key,
+        "title": node.attrs.get("title"),
+        "project": project,
+        "last_activity_at": node.attrs.get("last_activity_at"),
+    }
+
+
+def _match_file_keys(gs, query: str) -> list[str]:
+    q = normalize_path(query) or query.strip()
+    keys = [n.key for n in gs.nodes("file")]
+    exact = [k for k in keys if k == q]
+    if exact:
+        return sorted(exact)
+    ci = [k for k in keys if k.casefold() == q.casefold()]
+    if ci:
+        return sorted(ci)
+    return sorted(k for k in keys if k.endswith("/" + q) or k == q)
+
+
+def _match_project_keys(gs, query: str) -> list[str]:
+    q = normalize_path(query) or query.strip()
+    nodes = gs.nodes("project")
+    exact = [n for n in nodes if n.key == q]
+    if exact:
+        return sorted(n.key for n in exact)
+    named = [n for n in nodes if n.attrs.get("name") == query.strip()]
+    ci = [n for n in nodes
+          if n.key.casefold() == q.casefold()
+          or (n.attrs.get("name") or "").casefold() == query.strip().casefold()]
+    found = {n.key for n in named + ci}
+    if found:
+        return sorted(found)
+    return sorted(n.key for n in nodes
+                  if n.key.endswith("/" + q) or n.key == q)
+
+
+def _match_tool_keys(gs, query: str) -> list[str]:
+    q = query.strip()
+    return sorted(n.key for n in gs.nodes("tool")
+                  if n.key == q or n.key.casefold() == q.casefold())
+
+
+def _sessions_of_project(gs, project_key: str) -> list[str]:
+    return sorted(
+        e.src.split(":", 1)[1]
+        for e in gs.in_edges(f"project:{project_key}")
+        if e.kind == "runs_in"
+    )
+
+
+def sessions_for_file(gs, path: str) -> dict:
+    """Which sessions touched ``path``, via which tool calls."""
+    file_keys = _match_file_keys(gs, path)
+    tool_calls = []
+    session_ids: set[str] = set()
+    for fk in file_keys:
+        for e in gs.in_edges(f"file:{fk}"):
+            if e.kind != "file_touched":
+                continue
+            tool_calls.append({
+                "id": e.src.split(":", 1)[1],
+                "session_id": e.owner,
+                "file": fk,
+            })
+            if e.owner:
+                session_ids.add(e.owner)
+    tool_calls.sort(key=lambda t: t["id"])
+    sessions = [
+        _session_dict(gs, gs.node(f"session:{sid}"))
+        for sid in sorted(session_ids)
+        if gs.node(f"session:{sid}") is not None
+    ]
+    return {"query": path, "files": file_keys, "sessions": sessions,
+            "tool_calls": tool_calls}
+
+
+def sessions_for_tool(gs, name: str) -> dict:
+    """Which sessions/projects used tool ``name``."""
+    session_ids: set[str] = set()
+    projects: set[str] = set()
+    for key in _match_tool_keys(gs, name):
+        for e in gs.in_edges(f"tool:{key}"):
+            if e.kind == "tool_used" and e.owner:
+                session_ids.add(e.owner)
+    sessions = [
+        _session_dict(gs, gs.node(f"session:{sid}"))
+        for sid in sorted(session_ids)
+        if gs.node(f"session:{sid}") is not None
+    ]
+    for s in sessions:
+        if s["project"]:
+            projects.add(s["project"])
+    return {"tool": name, "sessions": sessions,
+            "projects": sorted(projects)}
+
+
+def tools_for_project(gs, query: str) -> dict:
+    """Tools used by sessions running in project ``query``."""
+    project_keys = _match_project_keys(gs, query)
+    session_ids = sorted({
+        sid for pk in project_keys for sid in _sessions_of_project(gs, pk)
+    })
+    tools: set[str] = set()
+    for sid in session_ids:
+        for e in gs.out_edges(f"session:{sid}"):
+            if e.kind == "tool_used":
+                tools.add(e.dst.split(":", 1)[1])
+    sessions = [
+        _session_dict(gs, gs.node(f"session:{sid}"))
+        for sid in session_ids
+        if gs.node(f"session:{sid}") is not None
+    ]
+    return {"query": query, "projects": project_keys, "tools": sorted(tools),
+            "sessions": sessions}
+
+
+def project_detail(gs, query: str) -> dict:
+    """One project: its sessions, the tools they used, the files they touched."""
+    keys = _match_project_keys(gs, query)
+    if not keys:
+        return {"project": None, "sessions": [], "tools": [], "files": []}
+    project_key = keys[0]
+    base = tools_for_project(gs, project_key)
+    session_ids = {s["id"] for s in base["sessions"]}
+    files = sorted({
+        e.dst.split(":", 1)[1]
+        for e in gs.edges("file_touched")
+        if e.owner in session_ids
+    })
+    return {"project": project_key, "sessions": base["sessions"],
+            "tools": base["tools"], "files": files}
+
+
+def projects_graph(gs) -> dict:
+    """Project-to-project adjacency for visualization (D3-style).
+
+    Two projects link when they share a tool (both used it) or a file (both
+    touched it); ``weight`` = number of shared entities.
+    """
+    projects = gs.nodes("project")
+    tools_by_project: dict[str, set[str]] = {p.key: set() for p in projects}
+    files_by_project: dict[str, set[str]] = {p.key: set() for p in projects}
+
+    for e in gs.edges("tool_used"):
+        proj = _project_of_session(gs, e.src.split(":", 1)[1])
+        if proj in tools_by_project:
+            tools_by_project[proj].add(e.dst.split(":", 1)[1])
+    for e in gs.edges("file_touched"):
+        proj = _project_of_session(gs, e.owner)
+        if proj in files_by_project:
+            files_by_project[proj].add(e.dst.split(":", 1)[1])
+
+    nodes = [{
+        "id": p.key,
+        "name": p.attrs.get("name"),
+        "sessions": _sessions_of_project(gs, p.key),
+    } for p in projects]
+
+    links = []
+    for a, b in combinations(sorted(tools_by_project), 2):
+        shared_tools = sorted(tools_by_project[a] & tools_by_project[b])
+        shared_files = sorted(files_by_project[a] & files_by_project[b])
+        if shared_tools or shared_files:
+            links.append({
+                "source": a, "target": b,
+                "weight": len(shared_tools) + len(shared_files),
+                "shared_tools": shared_tools,
+                "shared_files": shared_files,
+            })
+    return {"nodes": nodes, "links": links}
+
+
+def _project_of_session(gs, session_id: str | None) -> str | None:
+    if session_id is None:
+        return None
+    for e in gs.out_edges(f"session:{session_id}"):
+        if e.kind == "runs_in":
+            return e.dst.split(":", 1)[1]
+    return None
+
+
+def shared_files(gs) -> dict:
+    """Files touched by two or more distinct projects.
+
+    A file counts when ``file_touched`` edges link it to tool calls owned by
+    sessions running in different projects (``working_directory``). Each
+    entry carries the sorted project list and the session ids that touched
+    the file — useful both for collision audits and D3-style highlighting.
+    """
+    projects_of_file: dict[str, set[str]] = {}
+    sessions_of_file: dict[str, set[str]] = {}
+    for e in gs.edges("file_touched"):
+        if not e.owner:
+            continue
+        project = _project_of_session(gs, e.owner)
+        if project is None:
+            continue
+        file_key = e.dst.split(":", 1)[1]
+        projects_of_file.setdefault(file_key, set()).add(project)
+        sessions_of_file.setdefault(file_key, set()).add(e.owner)
+
+    files = []
+    for file_key in sorted(projects_of_file):
+        projects = sorted(projects_of_file[file_key])
+        if len(projects) < 2:
+            continue
+        node = gs.node(f"file:{file_key}")
+        files.append({
+            "file": file_key,
+            "name": node.attrs.get("name") if node else None,
+            "projects": projects,
+            "sessions": sorted(sessions_of_file[file_key]),
+        })
+    return {"count": len(files), "files": files}