entelligence-cli 0.1.97__tar.gz → 0.1.99__tar.gz

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.97
+Version: 0.1.99
 Summary: AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes
 Author-email: EntelligenceAI <info@entelligence.ai>
 Project-URL: Homepage, https://entelligence.ai

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli/api_client.py

@@ -759,6 +759,20 @@ class APIClient:
         """
         return self._eku_post("/agentInsightsIngest/", payload, org_uuid=org_uuid)
 
+    def ingest_agent_insights_structured(self, org_uuid: str, payload: dict) -> dict:
+        """`POST /agent-insights/ingest-structured/` — push locally-computed
+        session+task data to the coding-agent graph (ENT-3631/ENT-3634).
+
+        `payload` carries {orgUUID, clientVersion?, extractionVersion,
+        sessions:[...]}; org/user identity is derived server-side from the
+        token, same as `ingest_agent_insights`. Returns the parsed response
+        dict ({sessions_stored, sessions_skipped, tasks_written,
+        tasks_deferred, ...}), or `{"Error": "<message>"}` on failure.
+        """
+        return self._eku_post(
+            "/agent-insights/ingest-structured/", payload, org_uuid=org_uuid, timeout=120
+        )
+
     def fetch_organization_repos(self, org_uuid: str) -> dict:
         """`POST /fetchOrganizationRepos/` — list every repo connected to the org.
 

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli/commands/insights.py

@@ -135,6 +135,73 @@ _PUSH_COLUMNS = (
     "effort_level",
 )
 
+# ENT-3634 — the structured-ingest payload contract (ENT-3633). Bump if the
+# shape changes in a way older backends can't accept; must stay >= the
+# backend's own MIN_SUPPORTED_EXTRACTION_VERSION (agent_insights/controller.py).
+_STRUCTURED_EXTRACTION_VERSION = 1
+
+# cinsights' local column names -> the structured-ingest endpoint's field
+# names. Built by reading cinsights' actual `db/models.py`, not assumed —
+# several names differ (`agent_type` vs `agent`, `prompt_tokens` vs
+# `input_tokens`, the three *_waste columns vs *_waste_tokens, etc.). Fields
+# genuinely absent from cinsights today (repo_name, branch, is_automated,
+# per-task category/files_touched/counters) are simply not in either map and
+# stay unset on the wire — the backend already defaults them (ENT-3739 tracks
+# adding the missing per-task computation to cinsights).
+_SESSION_FIELD_MAP = {
+    "agent_type": "agent",
+    "model": "model",
+    "start_time": "start_time",
+    "end_time": "end_time",
+    "prompt_tokens": "input_tokens",
+    "completion_tokens": "output_tokens",
+    "turn_count": "turn_count",
+    "span_count": "span_count",
+    "interrupted_turn_waste": "interrupt_waste_tokens",
+    "repeated_edit_waste": "repeat_waste_tokens",
+    "failed_retry_waste": "retry_waste_tokens",
+    "floor_drift_score": "floor_drift",
+    "agent_version": "agent_version",
+    "effort_level": "effort_level",
+    "adaptive_thinking_disabled": "adaptive_thinking_disabled",
+}
+_TASK_FIELD_MAP = {
+    "task_number": "task_number",
+    "name": "name",
+    "description": "description",
+    "start_turn": "start_turn",
+    "end_turn": "end_turn",
+    "turn_count": "turn_count",
+    "prompt_tokens_total": "prompt_tokens_total",
+    "completion_tokens_total": "completion_tokens_total",
+    "context_at_start": "context_at_start",
+    "estimated_waste_tokens": "estimated_waste_tokens",
+}
+
+
+def _structured_session_payload(row: dict, tasks: list[dict] | None) -> dict:
+    """Map one `coding_session` row (+ its `task` rows) to the structured-ingest
+    endpoint's session shape (ENT-3634 / ENT-3633).
+
+    Field renames only — no new computation. `cached_tokens` is the one
+    exception, summing cinsights' two separate cache columns into the single
+    field the endpoint expects.
+    """
+    session: dict = {
+        wire: row[local] for local, wire in _SESSION_FIELD_MAP.items() if row.get(local) is not None
+    }
+    session["session_id"] = row.get("id")
+    cache_read = row.get("cache_read_tokens") or 0
+    cache_write = row.get("cache_write_tokens") or 0
+    if cache_read or cache_write:
+        session["cached_tokens"] = cache_read + cache_write
+    if tasks:
+        session["tasks"] = [
+            {wire: t[local] for local, wire in _TASK_FIELD_MAP.items() if t.get(local) is not None}
+            for t in tasks
+        ]
+    return session
+
 
 def _local_db_path() -> str | None:
     """Filesystem path of the local cinsights SQLite DB (where `index` writes)."""
@@ -222,15 +289,19 @@ def _sync_cmd(
     secrets_mode,
     limit,
 ):
-    """Push your locally-computed coding-agent session metrics to Entelligence.
+    """Push your locally-computed coding-agent sessions to Entelligence (Path A).
 
-    Refreshes the local index, then uploads the per-session metrics (tokens,
-    tool usage, quality + efficiency scores) — the same data the dashboard
-    shows. Identity (org + you) is derived server-side from your CLI token, and
-    re-runs upsert, so it's safe to cron daily.
+    Refreshes the local index, then uploads session + task data — the same
+    data the dashboard shows, and (ENT-3634) the same data that now lands on
+    the coding-agent graph, not just RDS metrics, via the structured-ingest
+    endpoint. Raw transcript text never leaves the machine. Identity (org +
+    you) is derived server-side from your CLI token, and re-runs upsert, so
+    it's safe to cron daily.
 
     With --transcripts, uploads the raw (redacted) transcript files to the store
-    for the ingestion worker instead of pushing metrics.
+    for the ingestion worker instead of pushing structured data — Path B.
+    Mutually exclusive with the default push for now (ENT-3732 tracks making
+    the two independently schedulable).
     """
     obj = ctx.obj or {}
     api_client = obj.get("api_client")
@@ -314,12 +385,16 @@ def _sync_cmd(
             if name:
                 bucket = skill_dist.setdefault(sr["session_id"], {})
                 bucket[name] = bucket.get(name, 0) + 1
-        # Per-session task segmentation (name + turn range + waste) — powers the
-        # task bands on the context-growth chart. Names/numbers only.
+        # Per-session task segmentation. Every column cinsights' `task` table
+        # actually has (ENT-3634) — description/turn_count/completion_tokens_total/
+        # context_at_start were dropped by the old SELECT, which only needed
+        # name/turn-range/waste for the context-growth chart; the structured-ingest
+        # endpoint (ENT-3631) needs the rest too.
         task_map: dict[str, list] = {}
         for tr in conn.execute(
-            "SELECT session_id, task_number, name, start_turn, end_turn, "
-            "prompt_tokens_total, estimated_waste_tokens FROM task ORDER BY task_number"
+            "SELECT session_id, task_number, name, description, start_turn, end_turn, "
+            "turn_count, prompt_tokens_total, completion_tokens_total, context_at_start, "
+            "estimated_waste_tokens FROM task ORDER BY task_number"
         ):
             task_map.setdefault(tr["session_id"], []).append(dict(tr))
         # LLM-generated per-session insights (category/title/content/severity).
@@ -331,8 +406,9 @@ def _sync_cmd(
     finally:
         conn.close()
 
-    # 3. Keep sessions newer than the high-water mark (unless --all), trim to the
-    #    metric columns, and dedup on the engine's stable session key.
+    # 3. Keep sessions newer than the high-water mark (unless --all), map to the
+    #    structured-ingest endpoint's field names (ENT-3634), and dedup on the
+    #    engine's stable session key.
     hwm = None if push_all else _read_high_water_mark()
     sessions: list[dict] = []
     max_seen: datetime | None = None
@@ -343,21 +419,20 @@ def _sync_cmd(
         # re-upload every run). The first sync (no HWM) still includes them once.
         if not push_all and hwm is not None and (last is None or last <= hwm):
             continue
-        session = {k: row.get(k) for k in _PUSH_COLUMNS if row.get(k) is not None}
-        session["session_id"] = row.get("id")  # stable engine key -> server dedups on it
+        session = _structured_session_payload(row, task_map.get(row.get("id")))
+        # Extras the structured-ingest endpoint doesn't read yet (ENT-3631 accepts
+        # and ignores them) — sent anyway so nothing here needs to change once the
+        # backend catches up (findings/coaching routing, Decision 1; RDS column
+        # parity for tool/skill distribution).
         td = tool_dist.get(row.get("id"))
         if td:
             session["tool_distribution"] = td
         sd = skill_dist.get(row.get("id"))
         if sd:
             session["skill_distribution"] = sd
-        # Per-session drill-down material: context growth (per-turn), tasks, insights.
         cg = row.get("context_growth_json")
         if cg:
             session["context_growth"] = cg  # already a JSON string in the engine DB
-        tasks = task_map.get(row.get("id"))
-        if tasks:
-            session["tasks"] = tasks
         insights = insight_map.get(row.get("id"))
         if insights:
             session["insights"] = insights
@@ -376,24 +451,35 @@ def _sync_cmd(
         return
 
     pushed = 0
-    stored_total = 0
+    sessions_stored_total = 0
+    tasks_written_total = 0
     client_version = _client_version()
     for i in range(0, len(sessions), batch_size):
         batch = sessions[i : i + batch_size]
         # orgUUID is only for the server's @require_org_access check; the backend
         # derives the real identity (org + dev) from the auth token, not the body.
-        payload = {"orgUUID": org_uuid, "clientVersion": client_version, "sessions": batch}
-        resp = api_client.ingest_agent_insights(org_uuid, payload)
+        payload = {
+            "orgUUID": org_uuid,
+            "clientVersion": client_version,
+            "extractionVersion": _STRUCTURED_EXTRACTION_VERSION,
+            "sessions": batch,
+        }
+        resp = api_client.ingest_agent_insights_structured(org_uuid, payload)
         if isinstance(resp, dict) and resp.get("Error"):
             raise click.ClickException(f"Sync failed after {pushed} session(s): {resp['Error']}")
-        stored_total += int(resp.get("stored") or 0) if isinstance(resp, dict) else 0
+        if isinstance(resp, dict):
+            sessions_stored_total += int(resp.get("sessions_stored") or 0)
+            tasks_written_total += int(resp.get("tasks_written") or 0)
         pushed += len(batch)
         click.echo(f"  pushed {pushed}/{len(sessions)}")
 
     if max_seen is not None:
         _write_high_water_mark(max_seen)
 
-    click.echo(f"Synced {pushed} session(s) ({stored_total} stored) to Entelligence.")
+    click.echo(
+        f"Synced {pushed} session(s) ({sessions_stored_total} stored, "
+        f"{tasks_written_total} tasks) to Entelligence."
+    )
 
 
 # ----- auto-push: fire `sync` in the background, throttled to once/day -----
@@ -601,6 +687,17 @@ _RE_IDE_CONTEXT_TAG = re.compile(r"<ide_[^>]*>.*?</ide_[^>]*>", re.IGNORECASE |
 _RE_USER_QUERY_TAG = re.compile(r"</?user_query>", re.IGNORECASE)
 
 
+def _kiro_homes() -> list[str]:
+    """Kiro home dirs to read session event logs from (~/.kiro).
+
+    Unlike the others there's no cinsights config to consult — the insights engine
+    has no Kiro source, so metrics for Kiro sessions come from the uploaded
+    transcript (``sync --transcripts``), not the local index. Prompts for the wrap
+    are read straight off disk here.
+    """
+    return [os.path.expanduser("~/.kiro")]
+
+
 def _strip_prompt_tags(text: str) -> str:
     """Drop `<ide_*>` blocks and unwrap Cursor's `<user_query>` tags."""
     text = _RE_IDE_CONTEXT_TAG.sub("", text)
@@ -686,6 +783,23 @@ def _user_prompt_text(obj: dict) -> str | None:
             txt = _codex_user_text((payload.get("message") or "").strip())
         if txt is None:
             return None
+    # --- Kiro -----------------------------------------------------------------
+    # Events are enveloped: {"id", "timestamp", "payload": {"type": ..., ...}} with
+    # no top-level "type" — that absence is what tells them apart from Codex, whose
+    # branches above match on their own line_type first.
+    elif not line_type and isinstance(obj.get("payload"), dict):
+        payload = obj["payload"]
+        ptype = payload.get("type")
+        if ptype == "user":
+            content = payload.get("content")
+            txt = content.strip() if isinstance(content, str) else None
+        elif ptype == "interaction_resolved":
+            # The developer answering a Kiro question — their words, so a real prompt.
+            selected = payload.get("selectedOption")
+            if payload.get("outcome") == "answered" and isinstance(selected, str):
+                txt = selected.strip()
+        if txt is None:
+            return None
     # --- Claude Code / Cursor -------------------------------------------------
     else:
         if line_type != "user" and obj.get("role") != "user":
@@ -737,6 +851,14 @@ def _extract_user_prompts(days: int, cap: int = _WRAP_MAX_PROMPTS) -> list[str]:
     for home in _codex_homes():
         files += glob.glob(os.path.join(home, "sessions", "**", "*.jsonl"), recursive=True)
         files += glob.glob(os.path.join(home, "archived_sessions", "**", "*.jsonl"), recursive=True)
+    # Kiro: one event log per session dir, <home>/sessions/<ws-hash>/<session-id>/
+    # messages.jsonl. Enveloped lines ({"payload": {"type": "user", ...}}) — handled
+    # in _user_prompt_text. Sub-executions are sub-agent turns, not the developer's,
+    # so they're deliberately not globbed here.
+    for home in _kiro_homes():
+        files += glob.glob(
+            os.path.join(home, "sessions", "*", "*", "messages.jsonl"),
+        )
     for f in files:
         try:
             if os.path.getmtime(f) < cutoff:

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli/upload/discovery.py

@@ -1127,6 +1127,217 @@ def _scan_sessions_in_parallel(sessions: list[Session], *, workers: int) -> None
                 progress.advance(task)
 
 
+# ----- Discovery: Kiro (session directories) ---------------------------------
+#
+# A Kiro session is a DIRECTORY, not a file: sessions/<ws-hash>/<session-id>/ holds
+# session.json (metadata) + messages.jsonl (event log), and sub-agent runs land in
+# sub-executions/<execution-id>.jsonl. We synthesize one NDJSON per session — a
+# `kiro_session` header line then the raw events, merged by timestamp — mirroring
+# the cursor_store/opencode pattern so scan, redaction, upload, and dedup are all
+# unchanged downstream. The backend's `detect_agent` sniffs the header type.
+
+KIRO_CACHE_ROOT = Path.home() / ".entelligence" / "cache" / "kiro"
+
+
+def _count_kiro_sessions(home: Path) -> int:
+    """Count session dirs under <home>/sessions/<ws-hash>/<session-id>/ (0 if none)."""
+    sessions_root = home / "sessions"
+    if not sessions_root.is_dir():
+        return 0
+    n = 0
+    try:
+        for ws_hash_dir in sessions_root.iterdir():
+            if not ws_hash_dir.is_dir():
+                continue
+            for session_dir in ws_hash_dir.iterdir():
+                if session_dir.is_dir() and (session_dir / "session.json").is_file():
+                    n += 1
+    except OSError:
+        return n
+    return n
+
+
+def _kiro_cwd(session_meta: dict) -> Path | None:
+    """The session's primary workspace root (``workspacePaths[0]``), else None.
+
+    None means the repo pre-filter can't place the session by cwd and falls back to
+    transcript-based recovery — see ``_partition_by_connected_repos``.
+    """
+    paths = session_meta.get("workspacePaths")
+    if isinstance(paths, list) and paths:
+        first = paths[0]
+        if isinstance(first, str) and first.strip():
+            return Path(first)
+    return None
+
+
+def _kiro_read_events(path: Path) -> list[dict]:
+    """Parse one Kiro JSONL event log; unparseable/non-dict lines are dropped."""
+    events: list[dict] = []
+    try:
+        data = path.read_bytes()
+    except OSError:
+        return events
+    for raw_line in data.split(b"\n"):
+        raw_line = raw_line.strip()
+        if not raw_line:
+            continue
+        try:
+            obj = json.loads(raw_line)
+        except (json.JSONDecodeError, UnicodeDecodeError, ValueError):
+            continue
+        if isinstance(obj, dict):
+            events.append(obj)
+    return events
+
+
+def _kiro_source_mtime(messages_mtime: float, session_dir: Path) -> float:
+    """Latest mtime across every file `_kiro_synthesize` reads for this session.
+
+    That is ``messages.jsonl`` plus any ``sub-executions/*.jsonl``. The cache
+    freshness guard compares against this so a sub-agent file updated after
+    ``messages.jsonl`` still triggers re-synthesis — comparing against
+    ``messages.jsonl`` alone would serve a cache missing those sub-agent events.
+    A missing/unreadable ``sub-executions/`` dir falls back to ``messages_mtime``.
+    """
+    latest = messages_mtime
+    sub_exec_dir = session_dir / "sub-executions"
+    if sub_exec_dir.is_dir():
+        try:
+            for sub_file in sub_exec_dir.iterdir():
+                if sub_file.suffix != ".jsonl":
+                    continue
+                with contextlib.suppress(OSError):
+                    latest = max(latest, sub_file.stat().st_mtime)
+        except OSError:
+            pass
+    return latest
+
+
+def _kiro_synthesize(session_meta: dict, messages_path: Path, session_dir: Path) -> bytes | None:
+    """Build one session's NDJSON: `kiro_session` header + events, merged by timestamp.
+
+    Sub-execution (sub-agent) events are merged inline so the whole conversation —
+    including sub-agent tool calls — travels as a single uploadable file.
+
+    Returns None when the session has no ``turn_end`` event: an empty or
+    metadata-only session has nothing worth uploading.
+    """
+    events = _kiro_read_events(messages_path)
+    sub_exec_dir = session_dir / "sub-executions"
+    if sub_exec_dir.is_dir():
+        try:
+            sub_files = sorted(p for p in sub_exec_dir.iterdir() if p.suffix == ".jsonl")
+        except OSError:
+            sub_files = []
+        for sub_file in sub_files:
+            events.extend(_kiro_read_events(sub_file))
+
+    # Stable sort on timestamp: equal/absent timestamps keep file order (main
+    # stream first, then each sub-execution in name order).
+    events.sort(key=lambda e: str(e.get("timestamp") or ""))
+
+    has_turns = any(
+        isinstance(e.get("payload"), dict) and e["payload"].get("type") == "turn_end"
+        for e in events
+    )
+    if not has_turns:
+        return None
+
+    # Marker key LAST so it always wins: if a future session.json carries its own
+    # `type`, spreading it after would clobber the `kiro_session` marker and the
+    # backend's detect_agent would fail to recognise the transcript (dropping it).
+    header = {**session_meta, "type": "kiro_session"}
+    lines = [json.dumps(header, separators=(",", ":"))]
+    lines.extend(json.dumps(e, separators=(",", ":")) for e in events)
+    return ("\n".join(lines) + "\n").encode()
+
+
+def find_kiro_candidates(home: HomeSpec, *, cache_root: Path | None = None) -> Iterator[Session]:
+    """Yield a Session per Kiro session, synthesizing an NDJSON transcript.
+
+    ``home.path`` is the Kiro home (holds ``sessions/``). Each session is materialized
+    to ``<cache_root>/<ws-hash>/<session-id>.jsonl`` and that file becomes the Session's
+    ``abs_path``, mirroring ``find_cursor_store_candidates``.
+
+    The cache is only rewritten when ``messages.jsonl`` is newer than it, so a re-run
+    over unchanged sessions costs a stat() rather than a full re-synthesis.
+    """
+    sessions_root = home.path / "sessions"
+    if not sessions_root.is_dir():
+        logger.debug("kiro: no sessions dir under %s", home.path)
+        return
+    root = cache_root or KIRO_CACHE_ROOT
+    try:
+        ws_hash_dirs = sorted(p for p in sessions_root.iterdir() if p.is_dir())
+    except OSError as exc:
+        logger.debug("kiro: cannot list %s: %s", sessions_root, exc)
+        return
+
+    for ws_hash_dir in ws_hash_dirs:
+        ws_hash = _safe_component(ws_hash_dir.name, "unknown")
+        try:
+            session_dirs = sorted(p for p in ws_hash_dir.iterdir() if p.is_dir())
+        except OSError:
+            continue
+        for session_dir in session_dirs:
+            session_json_path = session_dir / "session.json"
+            messages_path = session_dir / "messages.jsonl"
+            if not session_json_path.is_file() or not messages_path.is_file():
+                continue
+            try:
+                session_meta = json.loads(session_json_path.read_bytes())
+            except (OSError, json.JSONDecodeError, ValueError):
+                logger.debug("kiro: bad session.json in %s", session_dir)
+                continue
+            if not isinstance(session_meta, dict):
+                continue
+            try:
+                messages_mtime = messages_path.stat().st_mtime
+            except OSError:
+                continue
+            # Freshness is judged against every file the synthesis reads — not
+            # just messages.jsonl. Sub-executions are merged in too, and a
+            # sub-agent file updated after messages.jsonl would otherwise leave
+            # the cache "fresh" while missing those events.
+            source_mtime = _kiro_source_mtime(messages_mtime, session_dir)
+
+            session_id = _safe_component(session_meta.get("id") or session_dir.name, "session")
+            rel = Path(ws_hash) / f"{session_id}.jsonl"
+            abs_path = root / rel
+            cwd = _kiro_cwd(session_meta)
+
+            fresh = False
+            with contextlib.suppress(OSError):
+                fresh = abs_path.stat().st_mtime >= source_mtime
+            if not fresh:
+                data = _kiro_synthesize(session_meta, messages_path, session_dir)
+                if data is None:
+                    continue
+                try:
+                    abs_path.parent.mkdir(parents=True, exist_ok=True)
+                    abs_path.write_bytes(data)
+                except OSError as exc:
+                    logger.debug("kiro materialize failed %s: %s", abs_path, exc)
+                    continue
+            try:
+                st = abs_path.stat()
+            except OSError:
+                continue
+            yield Session(
+                agent=AgentKind.KIRO,
+                home_label=home.label,
+                abs_path=abs_path,
+                rel_path=rel,
+                size_bytes=st.st_size,
+                # messages.jsonl mtime, not the cache file's: the cache is rewritten
+                # on re-synthesis and would otherwise report every session as "just now".
+                mtime=datetime.fromtimestamp(messages_mtime, tz=UTC),
+                cwd=cwd,
+                secret_findings=[],
+            )
+
+
 def find_all_candidates(homes: Iterable[HomeSpec]) -> list[Session]:
     """Cheap pass: find every candidate session, no secret scan. Newest-first."""
     found: list[Session] = []
@@ -1141,6 +1352,8 @@ def find_all_candidates(homes: Iterable[HomeSpec]) -> list[Session]:
         elif home.kind is AgentKind.CURSOR:
             found.extend(find_cursor_store_candidates(home))
             cursor_homes_seen = True
+        elif home.kind is AgentKind.KIRO:
+            found.extend(find_kiro_candidates(home))
     # IDE composers live in state.vscdb (not under ~/.cursor). Discover once per
     # run when any Cursor home is configured — usage API joins on composerId.
     if cursor_homes_seen:
@@ -1325,14 +1538,15 @@ def _detect_candidate_homes(prefix: str, counter: Callable[[Path], int]) -> dict
     return out
 
 
-def auto_detect_homes() -> tuple[list[Path], list[Path], list[Path], list[Path]]:
-    """Return (claude_homes, codex_homes, opencode_homes, cursor_homes) auto-detected
-    that hold transcripts."""
+def auto_detect_homes() -> tuple[list[Path], list[Path], list[Path], list[Path], list[Path]]:
+    """Return (claude_homes, codex_homes, opencode_homes, cursor_homes, kiro_homes)
+    auto-detected that hold transcripts."""
     claude = sorted(_detect_candidate_homes(".claude", _count_cc_sessions).keys())
     codex = sorted(_detect_candidate_homes(".codex", _count_codex_sessions).keys())
     opencode = sorted(_detect_opencode_homes().keys())
     cursor = sorted(_detect_candidate_homes(".cursor", _count_cursor_sessions).keys())
-    return claude, codex, opencode, cursor
+    kiro = sorted(_detect_candidate_homes(".kiro", _count_kiro_sessions).keys())
+    return claude, codex, opencode, cursor, kiro
 
 
 def homes_from_config(cfg: UploadConfig) -> list[HomeSpec]:
@@ -1362,4 +1576,10 @@ def homes_from_config(cfg: UploadConfig) -> list[HomeSpec]:
             console.print(f"[yellow]skip:[/yellow] cursor-home {p} no longer exists")
             continue
         homes.append(HomeSpec(kind=AgentKind.CURSOR, path=p.resolve()))
+    for raw in cfg.kiro_homes:
+        p = Path(raw).expanduser()
+        if not p.is_dir():
+            console.print(f"[yellow]skip:[/yellow] kiro-home {p} no longer exists")
+            continue
+        homes.append(HomeSpec(kind=AgentKind.KIRO, path=p.resolve()))
     return homes

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli/upload/models.py

@@ -22,6 +22,7 @@ class AgentKind(StrEnum):
     CODEX = "codex"
     OPENCODE = "opencode"
     CURSOR = "cursor"
+    KIRO = "kiro"
 
 
 class HomeSpec(BaseModel):
@@ -127,11 +128,19 @@ class UploadConfig(BaseModel):
     # chats/<ws-hash>/<uuid>/ or acp-sessions/<uuid>/, so discovery synthesizes an NDJSON
     # transcript per session (see discovery.py), same as opencode.
     cursor_homes: list[str] = Field(default_factory=list)
+    # Kiro homes (e.g. ~/.kiro). A session is a DIRECTORY — sessions/<ws-hash>/<session-id>/
+    # holding session.json + messages.jsonl (+ sub-executions/*.jsonl) — so discovery
+    # synthesizes one NDJSON transcript per session (see discovery.py), same as cursor/opencode.
+    kiro_homes: list[str] = Field(default_factory=list)
     secrets_mode: Literal["redact", "allow", "skip"] = Field(default="redact")
     skip_prefixes: list[str] = Field(default_factory=list)
     entelligence: EntelligenceIdentity | None = None
 
     def needs_setup(self) -> bool:
         return not (
-            self.claude_homes or self.codex_homes or self.opencode_homes or self.cursor_homes
+            self.claude_homes
+            or self.codex_homes
+            or self.opencode_homes
+            or self.cursor_homes
+            or self.kiro_homes
         )

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli/upload/runner.py

@@ -372,13 +372,14 @@ def _backfill_missing_home_kinds(cfg: UploadConfig) -> bool:
     Returns:
         True if any kind was backfilled (caller should persist), else False.
     """
-    cc, cx, oc, cu = auto_detect_homes()
+    cc, cx, oc, cu, ki = auto_detect_homes()
     added = False
     for detected, attr in (
         (cc, "claude_homes"),
         (cx, "codex_homes"),
         (oc, "opencode_homes"),
         (cu, "cursor_homes"),
+        (ki, "kiro_homes"),
     ):
         if not getattr(cfg, attr) and detected:
             setattr(cfg, attr, [str(p) for p in detected])
@@ -413,12 +414,13 @@ def run_transcript_upload(
     if setup or (
         cfg.needs_setup() and not (claude_home or codex_home or opencode_home or cursor_home)
     ):
-        cc, cx, oc, cu = auto_detect_homes()
+        cc, cx, oc, cu, ki = auto_detect_homes()
         cfg.claude_homes = [str(p) for p in cc]
         cfg.codex_homes = [str(p) for p in cx]
         cfg.opencode_homes = [str(p) for p in oc]
         cfg.cursor_homes = [str(p) for p in cu]
-        if cc or cx or oc or cu:
+        cfg.kiro_homes = [str(p) for p in ki]
+        if cc or cx or oc or cu or ki:
             save_config(cfg)
     elif not (claude_home or codex_home or opencode_home or cursor_home) and (
         _backfill_missing_home_kinds(cfg)

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.97
+Version: 0.1.99
 Summary: AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes
 Author-email: EntelligenceAI <info@entelligence.ai>
 Project-URL: Homepage, https://entelligence.ai

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/entelligence_cli.egg-info/SOURCES.txt

@@ -68,7 +68,9 @@ tests/test_cursor_usage.py
 tests/test_discovery_head_unicode.py
 tests/test_discovery_opencode.py
 tests/test_incident_smoke.py
+tests/test_insights_kiro_prompts.py
 tests/test_insights_me_smoke.py
+tests/test_insights_structured_payload.py
 tests/test_pii.py
 tests/test_presigned_skip_index.py
 tests/test_router_commands.py
@@ -76,5 +78,6 @@ tests/test_security_commands.py
 tests/test_update_command.py
 tests/test_upload_cursor_store.py
 tests/test_upload_home_backfill.py
+tests/test_upload_kiro.py
 tests/test_upload_repo_filter.py
 tests/test_upload_repo_roots.py

{entelligence_cli-0.1.97 → entelligence_cli-0.1.99}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "entelligence-cli"
-version = "0.1.97"
+version = "0.1.99"
 description = "AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes"
 readme = "README.md"
 authors = [