repr-cli 0.2.22__tar.gz → 0.2.24__tar.gz

{repr_cli-0.2.22 → repr_cli-0.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repr-cli
-Version: 0.2.22
+Version: 0.2.24
 Summary: A beautiful, privacy-first CLI that analyzes your code repositories and generates a compelling developer profile
 Author-email: Repr <hello@repr.dev>
 License: MIT License

{repr_cli-0.2.22 → repr_cli-0.2.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "repr-cli"
-version = "0.2.22"
+version = "0.2.24"
 description = "A beautiful, privacy-first CLI that analyzes your code repositories and generates a compelling developer profile"
 readme = "README.md"
 license = {file = "LICENSE"}

{repr_cli-0.2.22 → repr_cli-0.2.24}/repr/change_synthesis.py

@@ -418,14 +418,25 @@ async def explain_group(
         changes=changes_str,
     )
 
-    response = await client.chat.completions.create(
-        model=model,
-        messages=[
-            {"role": "system", "content": GROUP_EXPLAIN_SYSTEM},
-            {"role": "user", "content": prompt},
-        ],
-        temperature=0.7,
-    )
+    async def make_request(use_temperature: bool = True):
+        kwargs = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": GROUP_EXPLAIN_SYSTEM},
+                {"role": "user", "content": prompt},
+            ],
+        }
+        if use_temperature:
+            kwargs["temperature"] = 0.7
+        return await client.chat.completions.create(**kwargs)
+
+    try:
+        response = await make_request(use_temperature=True)
+    except Exception as e:
+        if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+            response = await make_request(use_temperature=False)
+        else:
+            raise
 
     return response.choices[0].message.content.strip()
 
@@ -455,15 +466,26 @@ async def synthesize_changes(
         unpushed=format_commit_changes(report.unpushed),
     )
 
-    response = await client.chat.completions.create(
-        model=model,
-        messages=[
-            {"role": "system", "content": CHANGE_SYNTHESIS_SYSTEM},
-            {"role": "user", "content": prompt},
-        ],
-        response_format={"type": "json_object"},
-        temperature=0.7,
-    )
+    async def make_synthesis_request(use_temperature: bool = True):
+        kwargs = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": CHANGE_SYNTHESIS_SYSTEM},
+                {"role": "user", "content": prompt},
+            ],
+            "response_format": {"type": "json_object"},
+        }
+        if use_temperature:
+            kwargs["temperature"] = 0.7
+        return await client.chat.completions.create(**kwargs)
+
+    try:
+        response = await make_synthesis_request(use_temperature=True)
+    except Exception as e:
+        if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+            response = await make_synthesis_request(use_temperature=False)
+        else:
+            raise
 
     content = response.choices[0].message.content
     data = json.loads(content)

{repr_cli-0.2.22 → repr_cli-0.2.24}/repr/cli.py

@@ -6075,16 +6075,29 @@ def create_branch(
 
             prompt = COMMIT_MESSAGE_USER.format(changes=changes_str)
 
-            with create_spinner("Generating branch name..."):
-                response = asyncio.run(client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[
+            async def make_branch_request(use_temperature: bool = True):
+                kwargs = {
+                    "model": "gpt-4o-mini",
+                    "messages": [
                         {"role": "system", "content": COMMIT_MESSAGE_SYSTEM},
                         {"role": "user", "content": prompt},
                     ],
-                    response_format={"type": "json_object"},
-                    temperature=0.3,
-                ))
+                    "response_format": {"type": "json_object"},
+                }
+                if use_temperature:
+                    kwargs["temperature"] = 0.3
+                return await client.chat.completions.create(**kwargs)
+
+            async def get_branch_response():
+                try:
+                    return await make_branch_request(use_temperature=True)
+                except Exception as e:
+                    if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+                        return await make_branch_request(use_temperature=False)
+                    raise
+
+            with create_spinner("Generating branch name..."):
+                response = asyncio.run(get_branch_response())
                 data = json.loads(response.choices[0].message.content)
                 branch_name = data.get("branch", "")
                 commit_msg = data.get("message", "")
@@ -6227,16 +6240,29 @@ def commit_staged(
             changes_str = format_file_changes(staged)
             prompt = COMMIT_MESSAGE_USER.format(changes=changes_str)
 
-            with create_spinner("Generating commit message..."):
-                response = asyncio.run(client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[
+            async def make_commit_request(use_temperature: bool = True):
+                kwargs = {
+                    "model": "gpt-4o-mini",
+                    "messages": [
                         {"role": "system", "content": COMMIT_MESSAGE_SYSTEM},
                         {"role": "user", "content": prompt},
                     ],
-                    response_format={"type": "json_object"},
-                    temperature=0.3,
-                ))
+                    "response_format": {"type": "json_object"},
+                }
+                if use_temperature:
+                    kwargs["temperature"] = 0.3
+                return await client.chat.completions.create(**kwargs)
+
+            async def get_commit_response():
+                try:
+                    return await make_commit_request(use_temperature=True)
+                except Exception as e:
+                    if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+                        return await make_commit_request(use_temperature=False)
+                    raise
+
+            with create_spinner("Generating commit message..."):
+                response = asyncio.run(get_commit_response())
                 data = json.loads(response.choices[0].message.content)
                 branch_name = data.get("branch", "")
                 commit_msg = data.get("message", "")
@@ -6665,16 +6691,29 @@ def create_pr(
 
         prompt = PR_USER.format(commits=commits_text)
 
-        with create_spinner("Generating PR..."):
-            response = asyncio.run(client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
+        async def make_pr_request(use_temperature: bool = True):
+            kwargs = {
+                "model": "gpt-4o-mini",
+                "messages": [
                     {"role": "system", "content": PR_SYSTEM},
                     {"role": "user", "content": prompt},
                 ],
-                response_format={"type": "json_object"},
-                temperature=0.3,
-            ))
+                "response_format": {"type": "json_object"},
+            }
+            if use_temperature:
+                kwargs["temperature"] = 0.3
+            return await client.chat.completions.create(**kwargs)
+
+        async def get_pr_response():
+            try:
+                return await make_pr_request(use_temperature=True)
+            except Exception as e:
+                if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+                    return await make_pr_request(use_temperature=False)
+                raise
+
+        with create_spinner("Generating PR..."):
+            response = asyncio.run(get_pr_response())
             data = json.loads(response.choices[0].message.content)
             pr_title = data.get("title", current_branch)
             pr_body = data.get("body", "")

{repr_cli-0.2.22 → repr_cli-0.2.24}/repr/session_extractor.py

@@ -319,18 +319,29 @@ class SessionExtractor:
         # Call LLM (using sync client to avoid event loop cleanup issues)
         client = self._get_client()
 
-        try:
-            response = client.chat.completions.create(
-                model=self.model.split("/")[-1] if "/" in self.model else self.model,
-                messages=[
+        def make_extraction_request(use_temperature: bool = True):
+            kwargs = {
+                "model": self.model.split("/")[-1] if "/" in self.model else self.model,
+                "messages": [
                     {"role": "system", "content": EXTRACTION_SYSTEM_PROMPT},
                     {"role": "user", "content": EXTRACTION_USER_PROMPT.format(
                         session_transcript=transcript
                     )},
                 ],
-                response_format={"type": "json_object"},
-                temperature=0.3,
-            )
+                "response_format": {"type": "json_object"},
+            }
+            if use_temperature:
+                kwargs["temperature"] = 0.3
+            return client.chat.completions.create(**kwargs)
+
+        try:
+            try:
+                response = make_extraction_request(use_temperature=True)
+            except Exception as e:
+                if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+                    response = make_extraction_request(use_temperature=False)
+                else:
+                    raise
 
             # Parse response
             content = response.choices[0].message.content

{repr_cli-0.2.22 → repr_cli-0.2.24}/repr/story_synthesis.py

@@ -559,10 +559,20 @@ class StorySynthesizer:
                 return llm_config["local_model"]
             elif default_mode == "cloud" and llm_config.get("cloud_model"):
                 return llm_config["cloud_model"]
-
-            # Fallback to any configured model
-            if llm_config.get("local_model"):
-                return llm_config["local_model"]
+            elif default_mode.startswith("byok:"):
+                # BYOK mode - use the provider's configured model
+                provider = default_mode.split(":", 1)[1]
+                byok_config = llm_config.get("byok", {}).get(provider, {})
+                if byok_config.get("model"):
+                    return byok_config["model"]
+
+            # Fallback to BYOK model if configured
+            byok = llm_config.get("byok", {})
+            for provider_config in byok.values():
+                if provider_config.get("model"):
+                    return provider_config["model"]
+
+            # Fallback to cloud model
             if llm_config.get("cloud_model"):
                 return llm_config["cloud_model"]
         except Exception:
@@ -648,18 +658,29 @@ class StorySynthesizer:
         client = self._get_client()
         commits_text = self._format_commits_for_prompt(commits)
 
-        try:
-            response = client.chat.completions.create(
-                model=self.model.split("/")[-1] if "/" in self.model else self.model,
-                messages=[
+        def make_request(use_temperature: bool = True):
+            kwargs = {
+                "model": self.model.split("/")[-1] if "/" in self.model else self.model,
+                "messages": [
                     {"role": "system", "content": STORY_SYNTHESIS_SYSTEM},
                     {"role": "user", "content": STORY_SYNTHESIS_USER.format(
                         commits_text=commits_text
                     )},
                 ],
-                response_format={"type": "json_object"},
-                temperature=0.3,
-            )
+                "response_format": {"type": "json_object"},
+            }
+            if use_temperature:
+                kwargs["temperature"] = 0.3
+            return client.chat.completions.create(**kwargs)
+
+        try:
+            try:
+                response = make_request(use_temperature=True)
+            except Exception as e:
+                if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+                    response = make_request(use_temperature=False)
+                else:
+                    raise
 
             content = response.choices[0].message.content
 
@@ -1061,17 +1082,28 @@ async def transform_story_for_feed(
         )
         response_model = InternalStory
 
-    try:
-        # Use sync client to avoid event loop cleanup issues
-        response = client.chat.completions.create(
-            model=model_name.split("/")[-1] if "/" in model_name else model_name,
-            messages=[
+    def make_story_request(use_temperature: bool = True):
+        kwargs = {
+            "model": model_name.split("/")[-1] if "/" in model_name else model_name,
+            "messages": [
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": user_prompt},
             ],
-            response_format={"type": "json_object"},
-            temperature=0.7,
-        )
+            "response_format": {"type": "json_object"},
+        }
+        if use_temperature:
+            kwargs["temperature"] = 0.7
+        return client.chat.completions.create(**kwargs)
+
+    try:
+        # Use sync client to avoid event loop cleanup issues
+        try:
+            response = make_story_request(use_temperature=True)
+        except Exception as e:
+            if "temperature" in str(e).lower() and "unsupported" in str(e).lower():
+                response = make_story_request(use_temperature=False)
+            else:
+                raise
 
         content = response.choices[0].message.content.strip()
 

{repr_cli-0.2.22 → repr_cli-0.2.24}/repr_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repr-cli
-Version: 0.2.22
+Version: 0.2.24
 Summary: A beautiful, privacy-first CLI that analyzes your code repositories and generates a compelling developer profile
 Author-email: Repr <hello@repr.dev>
 License: MIT License