intent-cli-python 1.2.0__tar.gz → 1.3.0__tar.gz

{intent_cli_python-1.2.0 → intent_cli_python-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intent-cli-python
-Version: 1.2.0
+Version: 1.3.0
 Summary: Semantic history for agent-driven development. Records what you did and why.
 Author: Zeng Deyang
 License-Expression: MIT
@@ -72,6 +72,24 @@ pip install intent-cli-python
 
 Requires Python 3.9+ and Git.
 
+### Run the local IntHub shell
+
+The first read-only IntHub shell now ships with the package:
+
+```bash
+inthub-api --db-path .inthub/inthub.db
+inthub-web --api-base-url http://127.0.0.1:8000
+```
+
+If you are running from source instead of an installed package, the same entrypoints are available with:
+
+```bash
+python -m apps.inthub_api --db-path .inthub/inthub.db
+python -m apps.inthub_web --api-base-url http://127.0.0.1:8000
+```
+
+Then use `itt hub login`, `itt hub link`, and `itt hub sync` from a local Intent workspace to populate the read-only IntHub project view.
+
 ### Install the skills.sh skill
 
 ```bash

{intent_cli_python-1.2.0 → intent_cli_python-1.3.0}/README.md

@@ -48,6 +48,24 @@ pip install intent-cli-python
 
 Requires Python 3.9+ and Git.
 
+### Run the local IntHub shell
+
+The first read-only IntHub shell now ships with the package:
+
+```bash
+inthub-api --db-path .inthub/inthub.db
+inthub-web --api-base-url http://127.0.0.1:8000
+```
+
+If you are running from source instead of an installed package, the same entrypoints are available with:
+
+```bash
+python -m apps.inthub_api --db-path .inthub/inthub.db
+python -m apps.inthub_web --api-base-url http://127.0.0.1:8000
+```
+
+Then use `itt hub login`, `itt hub link`, and `itt hub sync` from a local Intent workspace to populate the read-only IntHub project view.
+
 ### Install the skills.sh skill
 
 ```bash

intent_cli_python-1.3.0/apps/__init__.py

@@ -0,0 +1 @@
+"""App packages for the Intent monorepo."""

intent_cli_python-1.3.0/apps/inthub_api/__init__.py

@@ -0,0 +1 @@
+"""IntHub API package."""

intent_cli_python-1.3.0/apps/inthub_api/__main__.py

@@ -0,0 +1,4 @@
+from apps.inthub_api.server import main
+
+
+main()

intent_cli_python-1.3.0/apps/inthub_api/common.py

@@ -0,0 +1,43 @@
+"""Shared helpers for the IntHub API."""
+
+import uuid
+from datetime import datetime, timezone
+
+
+def now_utc():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def new_id(prefix):
+    return f"{prefix}_{uuid.uuid4().hex[:12]}"
+
+
+def make_remote_object_id(workspace_id, local_object_id):
+    return f"{workspace_id}__{local_object_id}"
+
+
+def split_remote_object_id(remote_object_id):
+    parts = remote_object_id.split("__", 1)
+    if len(parts) != 2:
+        raise ValueError("Invalid remote object ID.")
+    return parts[0], parts[1]
+
+
+class APIError(Exception):
+    def __init__(self, code, message, status=400, details=None):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.status = status
+        self.details = details or {}
+
+
+def require_repo(repo):
+    required = ("provider", "repo_id", "owner", "name")
+    missing = [key for key in required if not repo.get(key)]
+    if missing:
+        raise APIError(
+            "INVALID_INPUT",
+            f"Missing repo fields: {', '.join(missing)}.",
+            status=400,
+        )

intent_cli_python-1.3.0/apps/inthub_api/db.py

@@ -0,0 +1,47 @@
+"""SQLite helpers for the IntHub API."""
+
+import sqlite3
+from pathlib import Path
+
+
+def connect(db_path):
+    path = Path(db_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(path, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    init_db(conn)
+    return conn
+
+
+def init_db(conn):
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS projects (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            provider TEXT NOT NULL,
+            repo_id TEXT NOT NULL UNIQUE,
+            owner TEXT NOT NULL,
+            repo_name TEXT NOT NULL,
+            created_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS workspaces (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL,
+            provider TEXT NOT NULL,
+            repo_id TEXT NOT NULL,
+            created_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS sync_batches (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL,
+            workspace_id TEXT NOT NULL,
+            generated_at TEXT NOT NULL,
+            accepted_at TEXT NOT NULL,
+            payload_json TEXT NOT NULL
+        );
+        """
+    )
+    conn.commit()

intent_cli_python-1.3.0/apps/inthub_api/ingest.py

@@ -0,0 +1,170 @@
+"""Write-path logic for the IntHub API."""
+
+import json
+
+from apps.inthub_api.common import APIError, new_id, now_utc, require_repo
+from apps.inthub_api.db import connect
+
+
+def link_project(db_path, project_name, repo, workspace_id):
+    require_repo(repo)
+    if repo.get("provider") != "github":
+        raise APIError(
+            "PROVIDER_UNSUPPORTED",
+            f"Unsupported provider '{repo.get('provider')}'.",
+            status=400,
+        )
+
+    with connect(db_path) as conn:
+        project = conn.execute(
+            "SELECT * FROM projects WHERE provider = ? AND repo_id = ?",
+            (repo["provider"], repo["repo_id"]),
+        ).fetchone()
+
+        if project is None:
+            project_id = new_id("proj")
+            conn.execute(
+                """
+                INSERT INTO projects (id, name, provider, repo_id, owner, repo_name, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    project_id,
+                    project_name or repo["name"],
+                    repo["provider"],
+                    repo["repo_id"],
+                    repo["owner"],
+                    repo["name"],
+                    now_utc(),
+                ),
+            )
+        else:
+            project_id = project["id"]
+
+        if not workspace_id:
+            workspace_id = new_id("wks")
+
+        workspace = conn.execute(
+            "SELECT * FROM workspaces WHERE id = ?",
+            (workspace_id,),
+        ).fetchone()
+        if workspace is None:
+            conn.execute(
+                """
+                INSERT INTO workspaces (id, project_id, provider, repo_id, created_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (workspace_id, project_id, repo["provider"], repo["repo_id"], now_utc()),
+            )
+        else:
+            if workspace["project_id"] != project_id or workspace["repo_id"] != repo["repo_id"]:
+                raise APIError(
+                    "STATE_CONFLICT",
+                    f"Workspace {workspace_id} is already linked to another project or repo.",
+                    status=409,
+                )
+
+        conn.commit()
+        return {
+            "project_id": project_id,
+            "workspace_id": workspace_id,
+            "repo_binding": {
+                "provider": repo["provider"],
+                "repo_id": repo["repo_id"],
+                "owner": repo["owner"],
+                "name": repo["name"],
+            },
+        }
+
+
+def store_sync_batch(db_path, payload):
+    required = ("sync_batch_id", "project_id", "repo", "workspace", "snapshot")
+    missing = [key for key in required if key not in payload]
+    if missing:
+        raise APIError(
+            "INVALID_INPUT",
+            f"Missing sync batch fields: {', '.join(missing)}.",
+            status=400,
+        )
+
+    repo = payload["repo"]
+    workspace = payload["workspace"]
+    require_repo(repo)
+
+    workspace_id = workspace.get("workspace_id")
+    if not workspace_id:
+        raise APIError("INVALID_INPUT", "Missing workspace.workspace_id.", status=400)
+
+    with connect(db_path) as conn:
+        existing = conn.execute(
+            "SELECT accepted_at FROM sync_batches WHERE id = ?",
+            (payload["sync_batch_id"],),
+        ).fetchone()
+        if existing is not None:
+            return {
+                "sync_batch_id": payload["sync_batch_id"],
+                "project_id": payload["project_id"],
+                "workspace_id": workspace_id,
+                "accepted_at": existing["accepted_at"],
+                "duplicate": True,
+            }
+
+        project = conn.execute(
+            "SELECT * FROM projects WHERE id = ?",
+            (payload["project_id"],),
+        ).fetchone()
+        if project is None:
+            raise APIError(
+                "OBJECT_NOT_FOUND",
+                f"Project {payload['project_id']} not found.",
+                status=404,
+            )
+        if project["provider"] != repo["provider"] or project["repo_id"] != repo["repo_id"]:
+            raise APIError(
+                "STATE_CONFLICT",
+                "Sync batch repo does not match the linked project repo.",
+                status=409,
+            )
+
+        workspace_row = conn.execute(
+            "SELECT * FROM workspaces WHERE id = ? AND project_id = ?",
+            (workspace_id, payload["project_id"]),
+        ).fetchone()
+        if workspace_row is None:
+            raise APIError(
+                "OBJECT_NOT_FOUND",
+                f"Workspace {workspace_id} is not linked to project {payload['project_id']}.",
+                status=404,
+            )
+
+        snapshot = payload["snapshot"]
+        if snapshot.get("schema_version") != "1.0":
+            raise APIError(
+                "SCHEMA_VERSION_MISMATCH",
+                f"Unsupported schema_version '{snapshot.get('schema_version')}'.",
+                status=400,
+            )
+
+        accepted_at = now_utc()
+        conn.execute(
+            """
+            INSERT INTO sync_batches (id, project_id, workspace_id, generated_at, accepted_at, payload_json)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                payload["sync_batch_id"],
+                payload["project_id"],
+                workspace_id,
+                payload.get("generated_at", accepted_at),
+                accepted_at,
+                json.dumps(payload, ensure_ascii=False),
+            ),
+        )
+        conn.commit()
+        return {
+            "sync_batch_id": payload["sync_batch_id"],
+            "project_id": payload["project_id"],
+            "workspace_id": workspace_id,
+            "accepted_at": accepted_at,
+            "duplicate": False,
+        }

intent_cli_python-1.3.0/apps/inthub_api/queries.py

@@ -0,0 +1,366 @@
+"""Read-model queries for the IntHub API."""
+
+import json
+
+from apps.inthub_api.common import APIError, make_remote_object_id, split_remote_object_id
+from apps.inthub_api.db import connect
+
+
+def _project_row(conn, project_id):
+    project = conn.execute(
+        "SELECT * FROM projects WHERE id = ?",
+        (project_id,),
+    ).fetchone()
+    if project is None:
+        raise APIError("OBJECT_NOT_FOUND", f"Project {project_id} not found.", status=404)
+    return project
+
+
+def _latest_payloads(conn, project_id):
+    rows = conn.execute(
+        """
+        SELECT sb.payload_json
+        FROM sync_batches AS sb
+        JOIN (
+            SELECT workspace_id, MAX(rowid) AS max_rowid
+            FROM sync_batches
+            WHERE project_id = ?
+            GROUP BY workspace_id
+        ) latest
+        ON sb.rowid = latest.max_rowid
+        ORDER BY sb.accepted_at DESC
+        """,
+        (project_id,),
+    ).fetchall()
+    return [json.loads(row["payload_json"]) for row in rows]
+
+
+def _workspace_state(payload):
+    return {
+        "workspace_id": payload["workspace"]["workspace_id"],
+        "last_synced_at": payload.get("generated_at"),
+        "branch": payload.get("git", {}).get("branch"),
+        "head_commit": payload.get("git", {}).get("head_commit"),
+        "dirty": payload.get("git", {}).get("dirty"),
+    }
+
+
+def _latest_snap_for_intent(intent, snaps):
+    snap_ids = intent.get("snap_ids", [])
+    if not snap_ids:
+        return None
+    latest_id = snap_ids[-1]
+    for snap in snaps:
+        if snap["id"] == latest_id:
+            return snap
+    return None
+
+
+def _latest_payload_for_workspace(conn, workspace_id):
+    row = conn.execute(
+        """
+        SELECT payload_json
+        FROM sync_batches
+        WHERE workspace_id = ?
+        ORDER BY rowid DESC
+        LIMIT 1
+        """,
+        (workspace_id,),
+    ).fetchone()
+    if row is None:
+        raise APIError(
+            "OBJECT_NOT_FOUND",
+            f"No sync batch found for workspace {workspace_id}.",
+            status=404,
+        )
+    return json.loads(row["payload_json"])
+
+
+def project_overview(db_path, project_id):
+    with connect(db_path) as conn:
+        project = _project_row(conn, project_id)
+        payloads = _latest_payloads(conn, project_id)
+
+    active_intents = []
+    active_decisions = []
+    recent_snaps = []
+    workspaces = []
+
+    for payload in payloads:
+        workspace_id = payload["workspace"]["workspace_id"]
+        snapshot = payload.get("snapshot", {})
+        git = payload.get("git", {})
+        workspaces.append(_workspace_state(payload))
+
+        intents = snapshot.get("intents", [])
+        snaps = snapshot.get("snaps", [])
+        decisions = snapshot.get("decisions", [])
+
+        for intent in intents:
+            if intent.get("status") != "active":
+                continue
+            active_intents.append({
+                "remote_id": make_remote_object_id(workspace_id, intent["id"]),
+                "workspace_id": workspace_id,
+                "id": intent["id"],
+                "title": intent["title"],
+                "status": intent["status"],
+                "decision_ids": intent.get("decision_ids", []),
+                "latest_snap_id": intent.get("snap_ids", [None])[-1] if intent.get("snap_ids") else None,
+                "branch": git.get("branch"),
+                "head_commit": git.get("head_commit"),
+                "dirty": git.get("dirty"),
+            })
+
+        for decision in decisions:
+            if decision.get("status") != "active":
+                continue
+            active_decisions.append({
+                "remote_id": make_remote_object_id(workspace_id, decision["id"]),
+                "workspace_id": workspace_id,
+                "id": decision["id"],
+                "title": decision["title"],
+                "status": decision["status"],
+                "intent_ids": decision.get("intent_ids", []),
+            })
+
+        for snap in snaps:
+            recent_snaps.append({
+                "remote_id": make_remote_object_id(workspace_id, snap["id"]),
+                "workspace_id": workspace_id,
+                "id": snap["id"],
+                "title": snap["title"],
+                "intent_id": snap.get("intent_id"),
+                "status": snap["status"],
+                "summary": snap.get("summary", ""),
+                "feedback": snap.get("feedback", ""),
+                "created_at": snap.get("created_at"),
+            })
+
+    recent_snaps.sort(key=lambda snap: snap.get("created_at", ""), reverse=True)
+    return {
+        "project": {
+            "id": project["id"],
+            "name": project["name"],
+            "repo": {
+                "provider": project["provider"],
+                "repo_id": project["repo_id"],
+                "owner": project["owner"],
+                "name": project["repo_name"],
+            },
+        },
+        "workspaces": workspaces,
+        "active_intents": active_intents,
+        "active_decisions": active_decisions,
+        "recent_snaps": recent_snaps[:10],
+    }
+
+
+def list_projects(db_path):
+    with connect(db_path) as conn:
+        rows = conn.execute(
+            """
+            SELECT
+                p.*,
+                COUNT(DISTINCT w.id) AS workspace_count,
+                MAX(sb.accepted_at) AS last_synced_at
+            FROM projects AS p
+            LEFT JOIN workspaces AS w
+                ON w.project_id = p.id
+            LEFT JOIN sync_batches AS sb
+                ON sb.project_id = p.id
+            GROUP BY p.id
+            ORDER BY COALESCE(MAX(sb.accepted_at), p.created_at) DESC, p.created_at DESC
+            """
+        ).fetchall()
+
+    return {
+        "projects": [
+            {
+                "id": row["id"],
+                "name": row["name"],
+                "repo": {
+                    "provider": row["provider"],
+                    "repo_id": row["repo_id"],
+                    "owner": row["owner"],
+                    "name": row["repo_name"],
+                },
+                "workspace_count": row["workspace_count"],
+                "last_synced_at": row["last_synced_at"],
+                "created_at": row["created_at"],
+            }
+            for row in rows
+        ]
+    }
+
+
+def project_handoff(db_path, project_id):
+    with connect(db_path) as conn:
+        project = _project_row(conn, project_id)
+        payloads = _latest_payloads(conn, project_id)
+
+    intents_view = []
+    active_decisions = []
+
+    for payload in payloads:
+        workspace_id = payload["workspace"]["workspace_id"]
+        snapshot = payload.get("snapshot", {})
+        git = payload.get("git", {})
+        intents = snapshot.get("intents", [])
+        snaps = snapshot.get("snaps", [])
+        decisions = snapshot.get("decisions", [])
+
+        for decision in decisions:
+            if decision.get("status") == "active":
+                active_decisions.append({
+                    "remote_id": make_remote_object_id(workspace_id, decision["id"]),
+                    "workspace_id": workspace_id,
+                    "id": decision["id"],
+                    "title": decision["title"],
+                    "status": decision["status"],
+                })
+
+        for intent in intents:
+            if intent.get("status") != "active":
+                continue
+            latest_snap = _latest_snap_for_intent(intent, snaps)
+            intents_view.append({
+                "remote_id": make_remote_object_id(workspace_id, intent["id"]),
+                "workspace_id": workspace_id,
+                "id": intent["id"],
+                "title": intent["title"],
+                "status": intent["status"],
+                "source_query": intent.get("source_query", ""),
+                "rationale": intent.get("rationale", ""),
+                "decision_ids": intent.get("decision_ids", []),
+                "latest_snap": latest_snap,
+                "git": {
+                    "branch": git.get("branch"),
+                    "head_commit": git.get("head_commit"),
+                    "dirty": git.get("dirty"),
+                },
+                "synced_at": payload.get("generated_at"),
+            })
+
+    return {
+        "project": {
+            "id": project["id"],
+            "name": project["name"],
+        },
+        "active_decisions": active_decisions,
+        "intents": intents_view,
+    }
+
+
+def get_intent_detail(db_path, remote_object_id):
+    workspace_id, local_object_id = split_remote_object_id(remote_object_id)
+    with connect(db_path) as conn:
+        payload = _latest_payload_for_workspace(conn, workspace_id)
+
+    snapshot = payload.get("snapshot", {})
+    intents = snapshot.get("intents", [])
+    snaps = snapshot.get("snaps", [])
+    for intent in intents:
+        if intent["id"] != local_object_id:
+            continue
+        related_snaps = [snap for snap in snaps if snap.get("intent_id") == local_object_id]
+        return {
+            "remote_id": remote_object_id,
+            "workspace_id": workspace_id,
+            "id": local_object_id,
+            "intent": intent,
+            "snaps": related_snaps,
+            "git": payload.get("git", {}),
+            "synced_at": payload.get("generated_at"),
+        }
+    raise APIError("OBJECT_NOT_FOUND", f"Intent {remote_object_id} not found.", status=404)
+
+
+def get_decision_detail(db_path, remote_object_id):
+    workspace_id, local_object_id = split_remote_object_id(remote_object_id)
+    with connect(db_path) as conn:
+        payload = _latest_payload_for_workspace(conn, workspace_id)
+
+    snapshot = payload.get("snapshot", {})
+    decisions = snapshot.get("decisions", [])
+    intents = snapshot.get("intents", [])
+    for decision in decisions:
+        if decision["id"] != local_object_id:
+            continue
+        related_intents = [intent for intent in intents if intent["id"] in decision.get("intent_ids", [])]
+        return {
+            "remote_id": remote_object_id,
+            "workspace_id": workspace_id,
+            "id": local_object_id,
+            "decision": decision,
+            "intents": related_intents,
+            "synced_at": payload.get("generated_at"),
+        }
+    raise APIError("OBJECT_NOT_FOUND", f"Decision {remote_object_id} not found.", status=404)
+
+
+def get_snap_detail(db_path, remote_object_id):
+    workspace_id, local_object_id = split_remote_object_id(remote_object_id)
+    with connect(db_path) as conn:
+        payload = _latest_payload_for_workspace(conn, workspace_id)
+
+    snapshot = payload.get("snapshot", {})
+    snaps = snapshot.get("snaps", [])
+    intents = snapshot.get("intents", [])
+    for snap in snaps:
+        if snap["id"] != local_object_id:
+            continue
+        parent_intent = None
+        intent_id = snap.get("intent_id")
+        if intent_id:
+            for intent in intents:
+                if intent["id"] == intent_id:
+                    parent_intent = intent
+                    break
+        return {
+            "remote_id": remote_object_id,
+            "workspace_id": workspace_id,
+            "id": local_object_id,
+            "snap": snap,
+            "intent": parent_intent,
+            "git": payload.get("git", {}),
+            "synced_at": payload.get("generated_at"),
+        }
+    raise APIError("OBJECT_NOT_FOUND", f"Snap {remote_object_id} not found.", status=404)
+
+
+def search_project(db_path, project_id, query):
+    with connect(db_path) as conn:
+        _project_row(conn, project_id)
+        payloads = _latest_payloads(conn, project_id)
+
+    q = (query or "").strip().lower()
+    matches = []
+    if not q:
+        return {"project_id": project_id, "query": query, "matches": matches}
+
+    for payload in payloads:
+        workspace_id = payload["workspace"]["workspace_id"]
+        snapshot = payload.get("snapshot", {})
+        for object_type in ("intents", "snaps", "decisions"):
+            for obj in snapshot.get(object_type, []):
+                fields = [
+                    obj.get("title", ""),
+                    obj.get("query", ""),
+                    obj.get("source_query", ""),
+                    obj.get("summary", ""),
+                    obj.get("rationale", ""),
+                ]
+                haystack = " ".join(fields).lower()
+                if q not in haystack:
+                    continue
+                matches.append({
+                    "object_type": object_type[:-1],
+                    "remote_id": make_remote_object_id(workspace_id, obj["id"]),
+                    "workspace_id": workspace_id,
+                    "id": obj["id"],
+                    "title": obj.get("title", ""),
+                    "status": obj.get("status", ""),
+                })
+
+    return {"project_id": project_id, "query": query, "matches": matches}