sniff-cli 1.0.0__tar.gz

sniff_cli-1.0.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: sniff-cli
+Version: 1.0.0
+Summary: A terminal-native AI-likelihood detection engine for Git repositories.
+Home-page: https://github.com/alphaonelabs/sniff
+Author: AlphaOneLabs
+Author-email: hello@alphaonelabs.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.3
+Requires-Dist: rich>=13.7.1
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: nltk>=3.8.1
+Requires-Dist: torch>=2.2.0
+Requires-Dist: transformers>=4.40.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: sentence-transformers>=2.7.0
+Requires-Dist: plotille>=5.0.0
+Requires-Dist: pyfiglet>=1.0.2
+Requires-Dist: anthropic
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Sniff 🐕
+**Offline AI Contribution Detection Engine for Git Repositories**
+
+Sniff is a terminal-native AI detection system designed to analyze Git repositories and estimate the likelihood that commits or code contributions were generated or heavily assisted by AI tools.
+
+It combines deterministic structural analysis with a local Large Language Model (GPT-2 via HuggingFace) to provide explainable AI-likelihood scoring — all within a beautiful, interactive terminal interface. **100% offline. Zero cloud APIs. Your code never leaves your machine.**
+
+---
+
+## 1. Problem Statement
+
+**AI-Generated Code Transparency & Governance in Modern Development**
+
+With the rapid rise of AI coding assistants such as GitHub Copilot and ChatGPT, developers are increasingly committing AI-generated code without fully understanding it.
+
+This creates several risks:
+- Technical debt accumulation
+- Security vulnerabilities
+- Loss of code ownership accountability
+- Academic integrity violations
+- Reduced code quality over time
+
+Currently, Git platforms provide no structured transparency layer to detect or analyze AI-assisted contributions.
+
+### Target Users
+- DevSecOps Teams
+- Enterprise Engineering Managers
+- Academic Institutions
+- Open Source Maintainers
+- Security Auditors
+
+### Existing Gaps
+- No repository-level AI usage analytics
+- No explainable AI-likelihood scoring for commits
+- No structured governance tools for AI contribution transparency
+
+---
+
+## 2. Root Cause Analysis
+
+AI-generated code often exhibits:
+- Highly structured and formal commit messages with low linguistic entropy
+- Boilerplate-heavy code patterns with repetitive variable naming
+- Large bursts of code additions in physically impossible time windows
+- Consistent function scaffolding (docstrings, uniform indentation, predictable naming)
+
+Existing approaches rely on simple keyword matching (fragile) or fully black-box cloud APIs (non-transparent). Sniff is the first offline, explainable alternative.
+
+---
+
+## 3. Solution: Tri-Engine ML Architecture
+
+Sniff uses a **three-signal hybrid detection pipeline** to compute a final probabilistic AI-likelihood score for every commit.
+
+### Engine 1: Text Perplexity (NLP)
+- Uses a local **HuggingFace GPT-2** model to calculate the log-probability perplexity of commit messages.
+- LLMs produce mathematically "perfect" text (low perplexity). Human writing is chaotic and bursty (high perplexity).
+- **Flag:** Perplexity < 30 → Score: 0.9
+
+### Engine 2: Code AST Entropy (Structural)
+- Parses code additions into a **Python Abstract Syntax Tree (AST)** to analyze structural complexity.
+- Detects AI signatures: high docstring density, low lexical entropy, uniform scaffold patterns.
+- Falls back to raw diff heuristics for non-Python code (React/JS/Go), detecting patterns like `useState + useEffect` bursts.
+- **Flag:** Low variable uniqueness ratio → Score: 0.3–0.4
+
+### Engine 3: Behavioral Velocity (Metadata)
+- Cross-references **Lines of Code added per minute** by parsing GitPython commit timestamps.
+- Flags physically impossible typing speeds (> 50 LPM).
+- **Flag:** Velocity > 50 LPM → Instant +0.4 boost to final score.
+
+### Score Aggregation
+```
+final_score = (text × 0.4) + (code × 0.4) + (velocity × 0.2) + amplification_boost
+```
+- Results in a deterministic, explainable AI-likelihood band: **Likely Human / Mixed / Likely AI-Assisted**
+
+---
+
+## 4. System Architecture
+
+```
+User → [sniff interactive] → Theme Selector → Repository Connect
+     → Git Graph Extraction (GitPython)
+     → Text Perplexity Engine (GPT-2 local)
+     → AST Code Entropy Engine (Python ast)
+     → Velocity Behavioral Engine (timestamps)
+     → Score Aggregation → Rich Dashboard + Plotille Charts
+```
+
+Sniff is **stateless** and requires no external database. All analysis runs in-memory.
+
+---
+
+## 5. Tech Stack
+
+| Layer | Technology |
+|---|---|
+| Language | Python 3.10+ |
+| CLI Framework | Typer |
+| UI & Layout | Rich (Tables/Panels) |
+| ASCII Charts | Plotille |
+| ASCII Typography | PyFiglet |
+| Git Data | GitPython |
+| NLP Model | HuggingFace Transformers (GPT-2) |
+| Code Parsing | Python `ast` |
+| ML Backend | PyTorch |
+
+---
+
+## 6. Installation
+
+```bash
+git clone https://github.com/mrgear111/sniff.git
+cd sniff
+python -m venv venv
+source venv/bin/activate
+pip install -e .
+```
+
+---
+
+## 7. Usage
+
+### Interactive REPL
+```bash
+sniff interactive
+```
+
+| Command | Description |
+|---|---|
+| `cd <path or url>` | Switch repo. Pastes GitHub URLs auto-clone to a local cache |
+| `scan [count]` | Analyze the N most recent commits. Default: 10 |
+| `stats [count]` | View contributor AI leaderboard. Default: 50 |
+| `theme` | Switch syntax color theme (Dark / Light / Colorblind) |
+| `clear` | Clear the terminal |
+| `exit` | Quit the session |
+
+### Headless / CI Mode
+```bash
+sniff scan --path /path/to/repo --json
+sniff stats --path /path/to/repo --json
+```
+
+---
+
+## 8. Disclaimer
+
+Sniff relies on statistical ML models and behavioral heuristics. It is a powerful auditing signal, not a definitive legal claim of AI generation. Results should always be reviewed by a human auditor before action is taken.

sniff_cli-1.0.0/README.md

@@ -0,0 +1,148 @@
+# Sniff 🐕
+**Offline AI Contribution Detection Engine for Git Repositories**
+
+Sniff is a terminal-native AI detection system designed to analyze Git repositories and estimate the likelihood that commits or code contributions were generated or heavily assisted by AI tools.
+
+It combines deterministic structural analysis with a local Large Language Model (GPT-2 via HuggingFace) to provide explainable AI-likelihood scoring — all within a beautiful, interactive terminal interface. **100% offline. Zero cloud APIs. Your code never leaves your machine.**
+
+---
+
+## 1. Problem Statement
+
+**AI-Generated Code Transparency & Governance in Modern Development**
+
+With the rapid rise of AI coding assistants such as GitHub Copilot and ChatGPT, developers are increasingly committing AI-generated code without fully understanding it.
+
+This creates several risks:
+- Technical debt accumulation
+- Security vulnerabilities
+- Loss of code ownership accountability
+- Academic integrity violations
+- Reduced code quality over time
+
+Currently, Git platforms provide no structured transparency layer to detect or analyze AI-assisted contributions.
+
+### Target Users
+- DevSecOps Teams
+- Enterprise Engineering Managers
+- Academic Institutions
+- Open Source Maintainers
+- Security Auditors
+
+### Existing Gaps
+- No repository-level AI usage analytics
+- No explainable AI-likelihood scoring for commits
+- No structured governance tools for AI contribution transparency
+
+---
+
+## 2. Root Cause Analysis
+
+AI-generated code often exhibits:
+- Highly structured and formal commit messages with low linguistic entropy
+- Boilerplate-heavy code patterns with repetitive variable naming
+- Large bursts of code additions in physically impossible time windows
+- Consistent function scaffolding (docstrings, uniform indentation, predictable naming)
+
+Existing approaches rely on simple keyword matching (fragile) or fully black-box cloud APIs (non-transparent). Sniff is the first offline, explainable alternative.
+
+---
+
+## 3. Solution: Tri-Engine ML Architecture
+
+Sniff uses a **three-signal hybrid detection pipeline** to compute a final probabilistic AI-likelihood score for every commit.
+
+### Engine 1: Text Perplexity (NLP)
+- Uses a local **HuggingFace GPT-2** model to calculate the log-probability perplexity of commit messages.
+- LLMs produce mathematically "perfect" text (low perplexity). Human writing is chaotic and bursty (high perplexity).
+- **Flag:** Perplexity < 30 → Score: 0.9
+
+### Engine 2: Code AST Entropy (Structural)
+- Parses code additions into a **Python Abstract Syntax Tree (AST)** to analyze structural complexity.
+- Detects AI signatures: high docstring density, low lexical entropy, uniform scaffold patterns.
+- Falls back to raw diff heuristics for non-Python code (React/JS/Go), detecting patterns like `useState + useEffect` bursts.
+- **Flag:** Low variable uniqueness ratio → Score: 0.3–0.4
+
+### Engine 3: Behavioral Velocity (Metadata)
+- Cross-references **Lines of Code added per minute** by parsing GitPython commit timestamps.
+- Flags physically impossible typing speeds (> 50 LPM).
+- **Flag:** Velocity > 50 LPM → Instant +0.4 boost to final score.
+
+### Score Aggregation
+```
+final_score = (text × 0.4) + (code × 0.4) + (velocity × 0.2) + amplification_boost
+```
+- Results in a deterministic, explainable AI-likelihood band: **Likely Human / Mixed / Likely AI-Assisted**
+
+---
+
+## 4. System Architecture
+
+```
+User → [sniff interactive] → Theme Selector → Repository Connect
+     → Git Graph Extraction (GitPython)
+     → Text Perplexity Engine (GPT-2 local)
+     → AST Code Entropy Engine (Python ast)
+     → Velocity Behavioral Engine (timestamps)
+     → Score Aggregation → Rich Dashboard + Plotille Charts
+```
+
+Sniff is **stateless** and requires no external database. All analysis runs in-memory.
+
+---
+
+## 5. Tech Stack
+
+| Layer | Technology |
+|---|---|
+| Language | Python 3.10+ |
+| CLI Framework | Typer |
+| UI & Layout | Rich (Tables/Panels) |
+| ASCII Charts | Plotille |
+| ASCII Typography | PyFiglet |
+| Git Data | GitPython |
+| NLP Model | HuggingFace Transformers (GPT-2) |
+| Code Parsing | Python `ast` |
+| ML Backend | PyTorch |
+
+---
+
+## 6. Installation
+
+```bash
+git clone https://github.com/mrgear111/sniff.git
+cd sniff
+python -m venv venv
+source venv/bin/activate
+pip install -e .
+```
+
+---
+
+## 7. Usage
+
+### Interactive REPL
+```bash
+sniff interactive
+```
+
+| Command | Description |
+|---|---|
+| `cd <path or url>` | Switch repo. Pastes GitHub URLs auto-clone to a local cache |
+| `scan [count]` | Analyze the N most recent commits. Default: 10 |
+| `stats [count]` | View contributor AI leaderboard. Default: 50 |
+| `theme` | Switch syntax color theme (Dark / Light / Colorblind) |
+| `clear` | Clear the terminal |
+| `exit` | Quit the session |
+
+### Headless / CI Mode
+```bash
+sniff scan --path /path/to/repo --json
+sniff stats --path /path/to/repo --json
+```
+
+---
+
+## 8. Disclaimer
+
+Sniff relies on statistical ML models and behavioral heuristics. It is a powerful auditing signal, not a definitive legal claim of AI generation. Results should always be reviewed by a human auditor before action is taken.

sniff_cli-1.0.0/setup.cfg

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

sniff_cli-1.0.0/setup.py

@@ -0,0 +1,45 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+# Read the contents of the README file
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="sniff-cli",
+    version="1.0.0",
+    author="AlphaOneLabs",
+    author_email="hello@alphaonelabs.com",
+    description="A terminal-native AI-likelihood detection engine for Git repositories.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/alphaonelabs/sniff",
+    packages=find_packages(),
+    install_requires=[
+        "typer>=0.12.3",
+        "rich>=13.7.1",
+        "questionary>=2.0.1",
+        "gitpython>=3.1.43",
+        "nltk>=3.8.1",
+        "torch>=2.2.0",
+        "transformers>=4.40.0",
+        "numpy>=1.26.0",
+        "sentence-transformers>=2.7.0",
+        "plotille>=5.0.0",
+        "pyfiglet>=1.0.2",
+        "anthropic",
+        "python-dotenv"
+    ],
+    entry_points={
+        "console_scripts": [
+            "sniff=sniff_cli.main:main",
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Environment :: Console",
+    ],
+    python_requires=">=3.9",
+)

sniff_cli-1.0.0/sniff_cli/detectors/baseline.py

@@ -0,0 +1,195 @@
+"""
+Author Style Baseline Engine
+─────────────────────────────
+Builds a statistical fingerprint of each developer's historical coding style 
+from their first N commits, then flags deviations in new commits.
+
+Signals tracked:
+  - avg_function_length: average lines per function
+  - avg_commit_size: average lines changed per commit
+  - comment_ratio: fraction of lines that are comments
+  - naming_style: dominant convention (snake_case, camelCase, etc.)
+  - avg_line_length: mean line length
+  - line_length_variance: how "regular" their line lengths are (low = AI)
+"""
+
+import re
+import math
+import statistics
+from collections import defaultdict, Counter
+
+
+def _mean(lst):
+    return statistics.mean(lst) if lst else 0.0
+
+def _stdev(lst):
+    return statistics.stdev(lst) if len(lst) >= 2 else 0.0
+
+def _comment_ratio(diff: str) -> float:
+    lines = [l.strip() for l in diff.split('\n') if l.strip()]
+    if not lines:
+        return 0.0
+    comments = sum(1 for l in lines if l.startswith(('#', '//', '/*', '*', '<!--')))
+    return comments / len(lines)
+
+def _avg_line_length(diff: str) -> float:
+    lines = [l for l in diff.split('\n') if l.strip()]
+    return _mean([len(l) for l in lines]) if lines else 0.0
+
+def _line_length_variance(diff: str) -> float:
+    """Low variance = suspiciously regular = AI-like."""
+    lines = [len(l) for l in diff.split('\n') if l.strip()]
+    return _stdev(lines) if lines else 0.0
+
+def _detect_naming_style(diff: str) -> str:
+    """Returns dominant naming style: 'snake_case', 'camelCase', 'mixed'."""
+    identifiers = re.findall(r'\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b', diff)
+    snake = sum(1 for i in identifiers if '_' in i and i.islower())
+    camel = sum(1 for i in identifiers if re.search(r'[a-z][A-Z]', i))
+    if snake > camel * 1.5:
+        return 'snake_case'
+    elif camel > snake * 1.5:
+        return 'camelCase'
+    return 'mixed'
+
+def _extract_function_lengths(diff: str) -> list:
+    """Rough estimation of function sizes from indentation patterns."""
+    lengths = []
+    current_fn_lines = 0
+    in_function = False
+    for line in diff.split('\n'):
+        stripped = line.strip()
+        if re.match(r'^(def |function |async function |const \w+ = \(|class )', stripped):
+            if in_function and current_fn_lines > 0:
+                lengths.append(current_fn_lines)
+            in_function = True
+            current_fn_lines = 1
+        elif in_function:
+            current_fn_lines += 1
+    if in_function and current_fn_lines > 0:
+        lengths.append(current_fn_lines)
+    return lengths
+
+
+class AuthorBaseline:
+    """Per-author style profile built from historical commits."""
+    
+    def __init__(self):
+        self.profiles = {}  # author -> style dict
+
+    def build_profiles(self, commits, get_commit_diff_fn):
+        """
+        Build a baseline from the OLDEST commits (which pre-date AI assistance).
+        Uses the oldest 30 commits per author to establish the baseline,
+        then flags the newest commits as deviations.
+        """
+        # Collect data per author (oldest commits first)
+        author_data = defaultdict(list)
+        for commit in reversed(commits):
+            author = commit.author.name
+            diff = get_commit_diff_fn(commit)
+            if not diff.strip():
+                continue
+            lines = [l for l in diff.split('\n') if l.strip()]
+            author_data[author].append({
+                'diff': diff,
+                'lines': len(lines),
+                'comment_ratio': _comment_ratio(diff),
+                'avg_line_length': _avg_line_length(diff),
+                'line_length_variance': _line_length_variance(diff),
+                'fn_lengths': _extract_function_lengths(diff),
+                'naming_style': _detect_naming_style(diff),
+            })
+
+        for author, entries in author_data.items():
+            # Use oldest half as baseline, newest half as subject of analysis
+            baseline_entries = entries[:max(1, len(entries) // 2)]
+            
+            commit_sizes = [e['lines'] for e in baseline_entries]
+            comment_ratios = [e['comment_ratio'] for e in baseline_entries]
+            line_lengths = [e['avg_line_length'] for e in baseline_entries]
+            variances = [e['line_length_variance'] for e in baseline_entries]
+            fn_lengths = []
+            for e in baseline_entries:
+                fn_lengths.extend(e['fn_lengths'])
+            naming_styles = [e['naming_style'] for e in baseline_entries]
+            dominant_naming = Counter(naming_styles).most_common(1)[0][0] if naming_styles else 'mixed'
+
+            self.profiles[author] = {
+                'avg_commit_size': _mean(commit_sizes),
+                'commit_size_stdev': _stdev(commit_sizes),
+                'avg_comment_ratio': _mean(comment_ratios),
+                'avg_line_length': _mean(line_lengths),
+                'avg_line_variance': _mean(variances),
+                'avg_fn_length': _mean(fn_lengths),
+                'dominant_naming': dominant_naming,
+                'total_baseline_commits': len(baseline_entries),
+            }
+
+    def analyze_deviation(self, author: str, diff: str) -> dict:
+        """
+        Compare a single commit's style against the author's baseline.
+        Returns a score 0-1 where high score = strong deviation from baseline.
+        """
+        if author not in self.profiles or not diff.strip():
+            return {"score": 0.0, "reason": "No baseline available"}
+        
+        profile = self.profiles[author]
+        # Need at least 5 baseline commits for reliable comparison
+        if profile['total_baseline_commits'] < 5:
+            return {"score": 0.0, "reason": "Insufficient baseline history"}
+
+        score = 0.0
+        reasons = []
+
+        lines = [l for l in diff.split('\n') if l.strip()]
+        commit_size = len(lines)
+        comment_ratio = _comment_ratio(diff)
+        line_variance = _line_length_variance(diff)
+        naming = _detect_naming_style(diff)
+        fn_lengths = _extract_function_lengths(diff)
+        avg_fn = _mean(fn_lengths) if fn_lengths else 0.0
+
+        baseline_size = profile['avg_commit_size']
+        baseline_stdev = profile['commit_size_stdev']
+
+        # ── 1. Commit size deviation ────────────────────────────────────────
+        if baseline_size > 0 and baseline_stdev > 0:
+            z_score = abs(commit_size - baseline_size) / (baseline_stdev + 1)
+            if z_score > 2.0:
+                score += 0.4
+                reasons.append(f"Commit size extreme outlier (z={z_score:.1f}σ from author baseline of {baseline_size:.0f} lines)")
+            elif z_score > 1.2:
+                score += 0.2
+                reasons.append(f"Unusual commit size (z={z_score:.1f}σ from author baseline)")
+
+        # ── 2. Comment ratio deviation ──────────────────────────────────────
+        baseline_cr = profile['avg_comment_ratio']
+        cr_diff = comment_ratio - baseline_cr
+        if cr_diff > 0.10 and commit_size > 15:
+            score += 0.25
+            reasons.append(f"Comment density spike (+{cr_diff*100:.0f}% above author baseline)")
+
+        # ── 3. Line length regularity (AI writes unnaturally consistent lines)─
+        baseline_var = profile['avg_line_variance']
+        if baseline_var > 4 and line_variance < (baseline_var * 0.5) and commit_size > 20:
+            score += 0.3
+            reasons.append(f"Abnormally regular line lengths (variance {line_variance:.1f} vs author baseline {baseline_var:.1f})")
+
+        # ── 4. Naming style shift ────────────────────────────────────────────
+        if naming != profile['dominant_naming'] and naming != 'mixed' and commit_size > 15:
+            score += 0.2
+            reasons.append(f"Naming style shift ({profile['dominant_naming']} → {naming})")
+
+        # ── 5. Function length anomaly ───────────────────────────────────────
+        baseline_fn = profile['avg_fn_length']
+        if baseline_fn > 0 and avg_fn > 0:
+            fn_ratio = avg_fn / baseline_fn
+            if fn_ratio > 1.8:
+                score += 0.25
+                reasons.append(f"Functions {fn_ratio:.1f}x longer than author historical average")
+
+        return {
+            "score": min(score, 1.0),
+            "reason": "; ".join(reasons) if reasons else "Style consistent with author baseline"
+        }