fm-smart-commit 1.1.0__tar.gz

fm_smart_commit-1.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,75 @@
+# 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/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fm-smart-commit"
+version = "1.1.0"
+description = "AI-powered Git commit message generator using Apple Intelligence"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    {name = "Maverick Brazill", email = "brazillmav@gmail.com"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "apple_fm_sdk",
+]
+
+[project.scripts]
+smartcommit = "smartcommit:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-asyncio",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["smartcommit*"]
+
+[tool.pypi]
+twine = "dist"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest",
+    "pytest-asyncio",
+]

fm_smart_commit-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fm_smart_commit-1.1.0/src/fm_smart_commit.egg-info/PKG-INFO

@@ -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/src/fm_smart_commit.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/fm_smart_commit.egg-info/PKG-INFO
+src/fm_smart_commit.egg-info/SOURCES.txt
+src/fm_smart_commit.egg-info/dependency_links.txt
+src/fm_smart_commit.egg-info/entry_points.txt
+src/fm_smart_commit.egg-info/requires.txt
+src/fm_smart_commit.egg-info/top_level.txt
+src/smartcommit/__init__.py
+tests/test_smartcommit.py

fm_smart_commit-1.1.0/src/fm_smart_commit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fm_smart_commit-1.1.0/src/fm_smart_commit.egg-info/entry_points.txt

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

fm_smart_commit-1.1.0/src/fm_smart_commit.egg-info/requires.txt

@@ -0,0 +1,5 @@
+apple_fm_sdk
+
+[dev]
+pytest
+pytest-asyncio

fm_smart_commit-1.1.0/src/fm_smart_commit.egg-info/top_level.txt

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

fm_smart_commit-1.1.0/src/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()

fm_smart_commit-1.1.0/tests/test_smartcommit.py

@@ -0,0 +1,233 @@
+import unittest
+import asyncio
+from unittest.mock import patch, MagicMock, AsyncMock
+import subprocess
+import sys
+from io import StringIO
+import importlib.util
+
+sys.path.insert(0, '..')
+
+spec = importlib.util.find_spec('apple_fm_sdk')
+if spec is None:
+    sys.modules['apple_fm_sdk'] = MagicMock()
+
+from smartcommit import (
+    quick_mode,
+    detailed_mode,
+    analyze_scope,
+    analyze_intent,
+    analyze_changes,
+    synthesize_message,
+    commit_flow,
+)
+
+
+class MockLanguageModelSession:
+    def __init__(self):
+        pass
+
+    async def respond(self, prompt: str) -> str:
+        if "SCOPE" in prompt:
+            return "user_auth.py, login.py, auth module"
+        elif "INTENT" in prompt:
+            return "To improve user authentication security"
+        elif "SPECIFIC CHANGES" in prompt:
+            return "added hashPassword function, updated validation"
+        elif "synthesize" in prompt.lower() or "generate" in prompt.lower():
+            return "feat: add hashPassword function for secure auth"
+        else:
+            return "feat: update authentication module"
+
+
+class MockSystemLanguageModel:
+    def is_available(self):
+        return True, ""
+
+
+class TestQuickMode(unittest.IsolatedAsyncioTestCase):
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_quick_mode_no_staged_changes(self, mock_session, mock_model, mock_run):
+        mock_run.return_value = MagicMock(stdout="")
+        
+        result = asyncio.run(quick_mode())
+        
+        self.assertIsNone(result)
+
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_quick_mode_success(self, mock_session, mock_model, mock_run):
+        mock_run.return_value = MagicMock(stdout="+ def new_func(): pass")
+        mock_model.return_value = MockSystemLanguageModel()
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(quick_mode())
+        
+        self.assertIsNotNone(result)
+        self.assertIn("feat:", result)
+
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_quick_mode_with_context(self, mock_session, mock_model, mock_run):
+        mock_run.return_value = MagicMock(stdout="+ def new_func(): pass")
+        mock_model.return_value = MockSystemLanguageModel()
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(quick_mode(developer_context="fixes ticket #123"))
+        
+        self.assertIsNotNone(result)
+
+
+class TestDetailedMode(unittest.IsolatedAsyncioTestCase):
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_detailed_mode_no_staged(self, mock_session, mock_model, mock_run):
+        mock_run.return_value = MagicMock(stdout="")
+        
+        result = asyncio.run(detailed_mode())
+        
+        self.assertIsNone(result)
+
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_detailed_mode_success(self, mock_session, mock_model, mock_run):
+        mock_run.return_value = MagicMock(stdout="+ def new_func(): pass")
+        mock_model.return_value = MockSystemLanguageModel()
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(detailed_mode())
+        
+        self.assertIsNotNone(result)
+        self.assertIn("feat:", result)
+
+
+class TestAnalyzeFunctions(unittest.IsolatedAsyncioTestCase):
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_analyze_scope(self, mock_session):
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(analyze_scope("+ new file", mock_session.return_value))
+        
+        self.assertIsNotNone(result)
+        self.assertIn("user_auth.py", result)
+
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_analyze_intent(self, mock_session):
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(analyze_intent("+ new file", mock_session.return_value))
+        
+        self.assertIsNotNone(result)
+
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_analyze_intent_with_context(self, mock_session):
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(
+            analyze_intent("+ new file", mock_session.return_value, "fixes #456")
+        )
+        
+        self.assertIsNotNone(result)
+
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_analyze_changes(self, mock_session):
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(analyze_changes("+ new file", mock_session.return_value))
+        
+        self.assertIsNotNone(result)
+
+
+class TestSynthesizeMessage(unittest.IsolatedAsyncioTestCase):
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_synthesize_message(self, mock_session):
+        mock_session.return_value = MockLanguageModelSession()
+        
+        result = asyncio.run(synthesize_message(
+            "auth.py",
+            "improve security",
+            "added hash function",
+            mock_session.return_value
+        ))
+        
+        self.assertIsNotNone(result)
+        self.assertIn("feat:", result)
+
+
+class TestCommitFlow(unittest.IsolatedAsyncioTestCase):
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.input', return_value='y')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_commit_flow_accept(self, mock_session, mock_model, mock_input, mock_run):
+        mock_run.return_value = MagicMock(stdout="+ test change")
+        mock_model.return_value = MockSystemLanguageModel()
+        mock_session.return_value = MockLanguageModelSession()
+        
+        asyncio.run(commit_flow(quick=True))
+        
+        mock_run.assert_called()
+
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.input', return_value='n')
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_commit_flow_reject(self, mock_session, mock_model, mock_input, mock_run):
+        mock_run.return_value = MagicMock(stdout="+ test change")
+        mock_model.return_value = MockSystemLanguageModel()
+        mock_session.return_value = MockLanguageModelSession()
+        
+        asyncio.run(commit_flow(quick=True))
+        
+        self.assertEqual(mock_run.call_count, 1)
+
+    @patch('smartcommit.subprocess.run')
+    @patch('smartcommit.input', side_effect=['r', 'y'])
+    @patch('smartcommit.fm.SystemLanguageModel')
+    @patch('smartcommit.fm.LanguageModelSession')
+    def test_commit_flow_retry(self, mock_session, mock_model, mock_input, mock_run):
+        mock_run.return_value = MagicMock(stdout="+ test change")
+        mock_model.return_value = MockSystemLanguageModel()
+        mock_session.return_value = MockLanguageModelSession()
+        
+        asyncio.run(commit_flow(quick=True))
+        
+        self.assertGreater(mock_run.call_count, 1)
+
+
+class TestCLIParsing(unittest.TestCase):
+    def test_quick_flag_parsing(self):
+        with patch('sys.argv', ['smartcommit.py', '-q']):
+            from smartcommit import argparse
+            parser = argparse.ArgumentParser()
+            parser.add_argument('-q', '--quick', action='store_true')
+            args = parser.parse_args()
+            self.assertTrue(args.quick)
+
+    def test_context_flag_parsing(self):
+        with patch('sys.argv', ['smartcommit.py', '-c', 'test context']):
+            from smartcommit import argparse
+            parser = argparse.ArgumentParser()
+            parser.add_argument('-c', '--context', type=str)
+            args = parser.parse_args()
+            self.assertEqual(args.context, 'test context')
+
+    def test_combined_flags(self):
+        with patch('sys.argv', ['smartcommit.py', '-q', '-c', 'test']):
+            from smartcommit import argparse
+            parser = argparse.ArgumentParser()
+            parser.add_argument('-q', '--quick', action='store_true')
+            parser.add_argument('-c', '--context', type=str)
+            args = parser.parse_args()
+            self.assertTrue(args.quick)
+            self.assertEqual(args.context, 'test')
+
+
+if __name__ == '__main__':
+    unittest.main()