sourcecode 3.2.2__tar.gz → 3.3.0__tar.gz

{sourcecode-3.2.2 → sourcecode-3.3.0}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [3.3.0] — 2026-07-29
+
+**A default you must remember to disable is the wrong default for someone else's code.**
+Telemetry moves from opt-out to opt-in. A minor and not a patch: no API changed, but a default
+about data leaving the machine did, and that is a change a user must be told about rather than
+discover.
+
+**Upgrade note.** If you ever ran `ask telemetry enable` or `ask telemetry disable`, nothing
+changes for you — your choice is on record and is honoured. If you never chose, telemetry is
+now off and `ask telemetry enable` is how you turn it on.
+
 ### Changed
 
 - **Telemetry is opt-in** (P-1). It was opt-out; with no explicit choice on record, nothing is

{sourcecode-3.2.2 → sourcecode-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 3.2.2
+Version: 3.3.0
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-3.2.2 → sourcecode-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "3.2.2"
+version = "3.3.0"
 description = "Persistent structural context and ultra-fast repeated analysis for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-3.2.2 → sourcecode-3.3.0}/src/sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "3.2.2"
+__version__ = "3.3.0"

{sourcecode-3.2.2 → sourcecode-3.3.0}/src/sourcecode/cli.py

@@ -8105,47 +8105,44 @@ def auth_status_cmd() -> None:
     """Show current authentication and plan status."""
     import json as _json
     try:
-        from sourcecode.license import (
-            _PRO_UNLOCK_ALL as _unlock,
-            _license_data as _ld,
-            is_pro as _ip,
-        )
+        from sourcecode.license import _license_data as _ld, entitlement as _entitlement
+        _ent = _entitlement()
     except Exception:
         _ld = None
-        _ip = False
-        _unlock = False
-
-    # While the early-adoption unlock is on, every Pro command runs. Reporting
-    # `pro: false` here contradicted the --help header and the commands' own
-    # behaviour: the status has to describe the gating that is actually in force,
-    # not the credential that happens to be absent.
-    _gating = {
-        "pro_gating": "disabled" if _unlock else "enabled",
-        "pro_effective": bool(_ip or _unlock),
-    }
-    if _unlock:
-        _gating["pro_reason"] = "early-adoption unlock: Pro commands run without a license"
-
-    if not _ld:
-        out: dict = {
-            "status": "unauthenticated",
-            "pro": bool(_unlock),
-            **_gating,
+        _ent = {
+            "entitlement": "free", "source": "free_tier", "authenticated": False,
+            "paywall_active": True, "when_it_changes": "", "free_repo_java_file_limit": None,
         }
-        sys.stdout.write(_json.dumps(out, ensure_ascii=False) + "\n")
-        sys.stdout.flush()
-        return
 
-    out = {
-        "status": "authenticated",
-        "auth_method": _ld.get("auth_method", "license_key"),
-        "email": _ld.get("email", ""),
-        "plan": _ld.get("plan", "unknown"),
-        "plan_status": _ld.get("status", "unknown"),
-        "pro": _ip,
-        "validated_at": _ld.get("validated_at") or _ld.get("activated_at") or "",
-        **_gating,
+    # P-2: one authority (`license.entitlement`) answers "what runs here, and why".
+    # The legacy keys below are *derived* from it rather than computed a second
+    # time — that is what stops `{"status": "unauthenticated", "pro": true}` from
+    # reappearing. They are deprecated and will be removed in a future major.
+    _pro = _ent["entitlement"] == "pro"
+    _legacy = {
+        "pro": _pro,
+        "pro_effective": _pro,
+        "pro_gating": "enabled" if _ent["paywall_active"] else "disabled",
     }
+    if _ent["source"] == "early_adoption_unlock":
+        _legacy["pro_reason"] = "early-adoption unlock: Pro commands run without a license"
+
+    out: dict = {
+        "status": "authenticated" if _ent["authenticated"] else "unauthenticated",
+        **_ent,
+        **_legacy,
+        "deprecated_fields": ["pro", "pro_effective", "pro_gating", "pro_reason"],
+    }
+    if _ld:
+        out.update({
+            "auth_method": _ld.get("auth_method", "license_key"),
+            "email": _ld.get("email", ""),
+            "plan": _ld.get("plan", "unknown"),
+            # The authority reads a missing status as active, so reporting
+            # "unknown" here would contradict the entitlement in the same object.
+            "plan_status": _ld.get("status", "active"),
+            "validated_at": _ld.get("validated_at") or _ld.get("activated_at") or "",
+        })
     sys.stdout.write(_json.dumps(out, indent=2, ensure_ascii=False) + "\n")
     sys.stdout.flush()
 

{sourcecode-3.2.2 → sourcecode-3.3.0}/src/sourcecode/license.py

@@ -376,16 +376,78 @@ def _maybe_revalidate() -> None:
         pass
 
 
-def _init() -> None:
-    global _license_data, is_pro
-    _license_data = _load_license_file()
-    is_pro = (
+def entitlement() -> dict:
+    """The one answer to "what runs here today, and why" (P-2).
+
+    `auth status` used to publish four fields about this — `status`, `pro`,
+    `pro_gating`, `pro_effective`, plus a `pro_reason` sentence — and they read as
+    a contradiction: `{"status": "unauthenticated", "pro": true}`. Each field was
+    true on its own axis; together they told a buyer nothing about what they have,
+    why they have it, or what changes when it ends. That is the ADR-0008 pattern
+    exactly, on the commercial surface instead of an analysis one.
+
+    Every published entitlement field is derived from this dict and nowhere else.
+
+    Keys:
+      entitlement        "pro" | "free" — what actually runs right now
+      source             why: "license_key" | "early_adoption_unlock" | "free_tier"
+      authenticated      whether a credential is on this machine (an independent
+                         fact: today one can be entitled to Pro without one)
+      paywall_active     whether the paywall is enforcing anything at all
+      when_it_changes    what a user loses when `source` stops applying, in the
+                         terms the gate actually uses — never a price
+      free_repo_java_file_limit
+                         the number the size gate compares against
+    """
+    authenticated = _license_data is not None
+    licensed = bool(
         _license_data is not None
         and _license_data.get("plan") == "pro"
         and _license_data.get("status", "active") != "inactive"
     )
-    if _PRO_UNLOCK_ALL:
-        is_pro = True  # TEMPORARY: early-adoption Pro unlock (see _PRO_UNLOCK_ALL)
+    if licensed:
+        source = "license_key"
+    elif _PRO_UNLOCK_ALL:
+        source = "early_adoption_unlock"
+    else:
+        source = "free_tier"
+
+    if source == "license_key":
+        when = "Your licence entitles you to Pro; nothing changes while it stays active."
+    elif source == "early_adoption_unlock":
+        when = (
+            "Pro runs without a licence during early adoption. When that ends, every command "
+            f"still runs at full output on repositories up to {_FREE_REPO_JAVA_FILE_LIMIT} Java "
+            "source files; above that, the heavy-analysis commands ask for Pro. Capability is "
+            "never what is gated — size, automation and team are."
+        )
+    else:
+        when = (
+            f"Every command runs at full output on repositories up to {_FREE_REPO_JAVA_FILE_LIMIT} "
+            "Java source files. Above that, the heavy-analysis commands require Pro."
+        )
+
+    return {
+        "entitlement": "pro" if (licensed or _PRO_UNLOCK_ALL) else "free",
+        "source": source,
+        "authenticated": authenticated,
+        "paywall_active": not _PRO_UNLOCK_ALL,
+        "when_it_changes": when,
+        "free_repo_java_file_limit": _FREE_REPO_JAVA_FILE_LIMIT,
+    }
+
+
+def _init() -> None:
+    """Load the credential and derive the entitlement from the one authority.
+
+    `is_pro` is what every gate reads (`can_use`, `require_feature`), and it is
+    computed here from `entitlement()` rather than beside it — a second copy of
+    this rule is how `auth status` came to publish a state the commands
+    contradicted (P-2).
+    """
+    global _license_data, is_pro
+    _license_data = _load_license_file()
+    is_pro = entitlement()["entitlement"] == "pro"
 
 
 _init()