fm-smart-commit 1.1.0__py3-none-any.whl

fm_smart_commit-1.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: fm-smart-commit
+Version: 1.1.0
+Summary: AI-powered Git commit message generator using Apple Intelligence
+Author-email: Maverick Brazill <brazillmav@gmail.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: apple_fm_sdk
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# Git SmartCommit CLI
+
+**AI-powered Git commit generation running *100% locally* on your Mac using Apple Intelligence.**
+
+SmartCommit is a lightweight CLI tool that analyzes your staged Git changes and generates concise, professional [Conventional Commits](https://www.conventionalcommits.org/) (`feat:`, `fix:`, `refactor:`, etc.). 
+
+Because it runs completely on-device using the Apple Foundation Models SDK, it offers massive advantages over cloud-based AI tools:
+
+* **Privacy-First:** Your codebase never leaves your machine. Perfect for enterprise, proprietary, or sensitive code.
+* **Zero API Costs:** No OpenAI API keys or GitHub Copilot subscriptions required. It uses the AI already built into your Mac.
+* ️**Fast:** Powered natively by Apple Silicon neural engines for instant inference.
+
+---
+
+##  Prerequisites
+
+Before installing, ensure your machine meets the hardware and software requirements for local Apple Intelligence:
+* **Hardware:** Apple Silicon Mac (M1 chip or newer).
+* **OS:** macOS 15.0 (Sequoia) or newer.
+* **Settings:** Apple Intelligence must be enabled on your Mac.
+
+---
+
+## Installation
+
+```bash
+# 1. Download the latest release
+curl -fsSL -o smartcommit https://github.com/brazill7/smart-commit/releases/latest/download/smartcommit
+
+# 2. Make the file executable
+chmod +x smartcommit
+
+# 3. Clear the macOS Gatekeeper quarantine flag (required for unsigned binaries)
+xattr -d com.apple.quarantine smartcommit
+
+# 4. Move it to your local bin so it can be run from anywhere
+sudo mv smartcommit /usr/local/bin/
+
+### (Optional) Set up a Git Alias
+If you want to use this tool natively within Git (e.g., typing `git sc` or `git smart-commit` etc. ), you can add a global alias:
+
+git config --global alias.sc '!smartcommit'
+git config --global alias.smart-commit '!smartcommit'
+```
+
+---
+
+## Usage
+
+Make sure you have staged your changes (`git add .`) before running the tool.
+
+### Option A: Using the Standalone Command
+If you skipped the alias step, you can just call the tool directly in your repository:
+
+`smartcommit`
+
+To provide custom context to the AI (like explaining  *why*  you made a change), use the `-c` flag:
+
+`smartcommit -c "race condition on the login screen"`
+
+
+### Option B: Using the Git Alias
+If you configured the `git smart-commit` alias, you can use it just like a native Git command:
+
+`git smart-commit`
+
+With custom context:
+
+`git smart-commit -c "refactored the login auth flow"`
+
+
+**Example Output:**
+> Analyzing diff...
+> Suggested commit: **fix: resolve race condition in login flow**
+> Accept this commit message? (y/n): 

fm_smart_commit-1.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+fm_smart_commit-1.1.0.dist-info/licenses/LICENSE,sha256=cqOdyLYvw3vvxQ-sN2LPGRop9Z2bb2dvSSQeV76Shn0,1068
+smartcommit/__init__.py,sha256=k27q3P5V2kgzwYOiX1DCqsHdzXq0Ke5yvxtP9nOiHfM,7197
+fm_smart_commit-1.1.0.dist-info/METADATA,sha256=89r73zn5NoPMDZ_dQB5tQd5eGthgTjvwpzKgp7_N36M,3434
+fm_smart_commit-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fm_smart_commit-1.1.0.dist-info/entry_points.txt,sha256=5p-H3LMlDnsl3h5tEzHwrq3Kx3k5GIEXZZ4-zXm8TCQ,49
+fm_smart_commit-1.1.0.dist-info/top_level.txt,sha256=f1KG6zVyN4mqVSJasNRmNGmGSyfQm6xTSZLa63pr-ow,12
+fm_smart_commit-1.1.0.dist-info/RECORD,,

fm_smart_commit-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fm_smart_commit-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+smartcommit = smartcommit:main

fm_smart_commit-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maverick B.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fm_smart_commit-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smartcommit

smartcommit/__init__.py

@@ -0,0 +1,211 @@
+import subprocess
+import asyncio
+import argparse
+from typing import Optional
+import apple_fm_sdk as fm
+
+
+async def analyze_scope(diff: str, session: fm.LanguageModelSession) -> str:
+    prompt = f"""
+            Analyze this git diff and identify the SCOPE of changes: what files, components, or modules are affected?
+            
+            Diff:
+            {diff}
+            
+            Output ONLY a brief list of affected areas (e.g., "user_auth.py, login component, API routes"). No other text.
+            """
+    response = await session.respond(prompt)
+    return response.strip()
+
+
+async def analyze_intent(diff: str, session: fm.LanguageModelSession, developer_context: Optional[str] = None) -> str:
+    context = f"\nDeveloper context: {developer_context}" if developer_context else ""
+    prompt = f"""
+        Analyze this git diff and identify the INTENT: why was this change made? What problem does it solve?{context}
+        
+        Diff:
+        {diff}
+        
+        Output ONLY a one-sentence intent summary. No other text.
+        """
+    response = await session.respond(prompt)
+    return response.strip()
+
+
+async def analyze_changes(diff: str, session: fm.LanguageModelSession) -> str:
+    prompt = f"""
+        Analyze this git diff and identify the SPECIFIC CHANGES: what functions, logic, or code patterns changed?
+        
+        Diff:
+        {diff}
+        
+        Output ONLY a brief list of what changed (e.g., "added calculateTotal function, refactored validation logic"). No other text.
+        """
+    response = await session.respond(prompt)
+    return response.strip()
+
+
+async def synthesize_message(scope: str, intent: str, changes: str, session: fm.LanguageModelSession) -> str:
+    prompt = f"""
+        You are a Git commit message generator. Using the following analysis, generate a SINGLE Conventional Commit message.
+        
+        Scope (what files/components): {scope}
+        Intent (why): {intent}
+        Changes (what): {changes}
+        
+        Rules:
+        - Use prefix: feat:, fix:, docs:, style:, refactor:, chore:
+        - Keep it under 72 characters if possible
+        - ONLY output the commit message, no quotes, no explanation
+        
+        Output:
+        """
+    response = await session.respond(prompt)
+    return response.strip().strip('"').strip("'")
+
+
+async def quick_mode(developer_context: Optional[str] = None) -> Optional[str]:
+    diff_process = subprocess.run(['git', 'diff', '--staged'], capture_output=True, text=True)
+    diff = diff_process.stdout.strip()
+
+    if not diff:
+        print("No staged changes found. Run `git add` first!")
+        return None
+
+    model = fm.SystemLanguageModel()
+    is_available, reason = model.is_available()
+    if not is_available:
+        print(f"Apple Intelligence unavailable: {reason}")
+        return None
+
+    session = fm.LanguageModelSession()
+
+    context_instruction = ""
+    if developer_context:
+        context_instruction = f"\nAdditional context from the developer to include/consider:\n\"{developer_context}\"\n"
+
+    prompt = f"""
+        You are a strictly formatted Git commit generator. Analyze the following code diff and generate a single commit message using the Conventional Commits standard.
+        
+        Allowed prefixes: feat:, fix:, docs:, style:, refactor:, chore:
+        
+        Rules:
+        - ONLY output the commit message. No conversational text.
+        - Do not wrap the output in quotes.
+        - Incorporate any additional context provided by the developer.
+        
+        Examples:
+        Diff: + function calculateTotal(a, b) {{ return a + b; }}
+        Output: feat: add calculateTotal function, which adds a and b and returns the total.
+        
+        Actual Diff to analyze:
+        {diff}
+        {context_instruction}
+        
+        Analyze the following code diff and generate a single commit message using the Conventional Commits standard.
+        
+        Allowed prefixes: feat:, fix:, docs:, style:, refactor:, chore:
+        
+        Output:
+        """
+
+    print("Analyzing diff (quick mode)...")
+    response = await session.respond(prompt)
+    return response.strip().strip('"').strip("'")
+
+
+async def detailed_mode(developer_context: Optional[str] = None) -> Optional[str]:
+    diff_process = subprocess.run(['git', 'diff', '--staged'], capture_output=True, text=True)
+    diff = diff_process.stdout.strip()
+
+    if not diff:
+        print("No staged changes found. Run `git add` first!")
+        return None
+
+    model = fm.SystemLanguageModel()
+    is_available, reason = model.is_available()
+    if not is_available:
+        print(f"Apple Intelligence unavailable: {reason}")
+        return None
+
+    session = fm.LanguageModelSession()
+
+    print("Analyzing diff (detailed mode - 3 parallel agents)...")
+
+    commit_msg = None
+    try:
+        async with asyncio.TaskGroup() as tg:
+            task_scope = tg.create_task(analyze_scope(diff, session))
+            task_intent = tg.create_task(analyze_intent(diff, session, developer_context))
+            task_changes = tg.create_task(analyze_changes(diff, session))
+
+        scope_result = task_scope.result()
+        intent_result = task_intent.result()
+        changes_result = task_changes.result()
+
+        print(f"  Scope: {scope_result[:50]}...")
+        print(f"  Intent: {intent_result[:50]}...")
+        print(f"  Changes: {changes_result[:50]}...")
+
+        print("Synthesizing results...")
+        commit_msg = await synthesize_message(scope_result, intent_result, changes_result, session)
+
+    except* Exception as e:
+        print(f"Error in parallel analysis: {e}")
+
+    return commit_msg
+
+
+async def commit_flow(developer_context: Optional[str] = None, quick: bool = False) -> None:
+    commit_msg = None
+    max_retries = 3
+
+    for attempt in range(max_retries):
+        if quick:
+            commit_msg = await quick_mode(developer_context)
+        else:
+            commit_msg = await detailed_mode(developer_context)
+
+        if not commit_msg:
+            return
+
+        print(f"\nSuggested commit: \033[92m{commit_msg}\033[0m")
+        user_input = input("Accept commit? (y/n/r): ")
+
+        if user_input.lower() == 'y':
+            subprocess.run(['git', 'commit', '-m', commit_msg])
+            print("Committed successfully!")
+            return
+        elif user_input.lower() == 'r':
+            print("Retrying...\n")
+            continue
+        else:
+            print("Commit aborted.")
+            return
+
+    print("Max retries reached. Commit aborted.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate smart Git commits using Apple Intelligence.")
+    parser.add_argument(
+        '-c', '--context',
+        type=str,
+        help='Additional context or intent to guide the AI (e.g., "fixes ticket #123")'
+    )
+    parser.add_argument(
+        '-q', '--quick',
+        action='store_true',
+        help='Use quick single-pass mode (faster but less detailed)'
+    )
+
+    args = parser.parse_args()
+
+    if args.quick:
+        print("Running in --quick mode\n")
+
+    asyncio.run(commit_flow(developer_context=args.context, quick=args.quick))
+
+
+if __name__ == "__main__":
+    main()